Bingo

It was a nice journey  to make an application just with TypeScript and Node ecosystem.  There are some missing parts ( e.g. testing the GUI – e2e in JS parlance)

However, some thoughts:

1. The ecosystem does not have good support for mono-repository (in C# parlance , solution with multiple referencing projects )
   • Yarn Workspaces helps
   • TypeScript compile should be configured
2. The fact that you wrote once time the definitions is overrated
   • Still some different models for Web API and Console and Web should exists, if you are a purinst ( no swagger reference for console …)
   • The possibilities of mistake  because of the same  model are not trivial
3. Some tools require better documentation
   1. Finding how in nest return an HTML file is …. gard
   2. The errors are not so self explanatory ( for example, referencing i n warn workspaces something without his references)
4. Docker really helps to have repeatable builds
   1. CLI is your best friend –  programming and devops
   2. Docker copying results files are perfect
5. In our days, to be a full cycle programmer is easy with open source and stacks for open source( GitHub, AzureDevOps, Heroku, others)

Bingo

We have already documented the process of reproducing our code on developer PC ( including docker …)  So now we should help programmers understand the code that we have create and it’s general use.

For this, for any project that we have :

1. We should  add a Readme.md file to explain the project

2. We should add documentation for any class

3. We should generate the documentation for any class in a readable form ( preferably html)

3. We should deploy somewhere the documentation

For the first point, this is very easy ( although painful to write ). However, we should add a link to the 4th point , the link to the documentation.

For point 2 and 3 (adding documentation for any class and generating html ), we could use https://typedoc.org/  .

And ,because we are used to docker, I created build_code_documentation.txt docker file that runs typedoc on every project

FROM node:10
WORKDIR /app
WORKDIR /app
COPY package.json ./package.json
COPY bingo-cards-api/package.json ./bingo-cards-api/package.json
COPY bingo-cards-api-objects/package.json ./bingo-cards-api-objects/package.json
COPY bingo-cards-ui/package.json ./bingo-cards-ui/package.json
COPY bingo-meeting-console/package.json ./bingo-meeting-console/package.json
COPY bingo-meeting-objects/package.json ./bingo-meeting-objects/package.json
COPY bingo-meeting-objects-test/package.json ./bingo-meeting-objects-test/package.json
COPY yarn.lock ./yarn.lock

RUN yarn install

COPY . ./

RUN npm install –global typedoc
RUN yarn build
RUN typedoc –mode file –out docs/source/bingo-cards-api –ignoreCompilerErrors  –excludePrivate –excludeProtected bingo-cards-api/src
RUN typedoc –mode file –out docs/source/bingo-cards-api-objects –ignoreCompilerErrors  –excludePrivate –excludeProtected bingo-cards-api-objects/src
RUN typedoc –mode file –out docs/source/bingo-cards-ui –ignoreCompilerErrors  –excludePrivate –excludeProtected bingo-cards-ui/src
RUN typedoc –mode file –out docs/source/bingo-meeting-console –ignoreCompilerErrors  –excludePrivate –excludeProtected bingo-meeting-console
RUN typedoc –mode file –out docs/source/bingo-meeting-objects –ignoreCompilerErrors  –excludePrivate –excludeProtected bingo-meeting-objects
RUN typedoc –mode file –out docs/source/bingo-meeting-objects-test –ignoreCompilerErrors  –excludePrivate –excludeProtected bingo-meeting-objects-test

CMD tail -f /dev/null

And the bat file just copy on hard disj

docker build .. -f docker_build_code_documentation.txt -t bingo_build_code_documentation
docker run -d –rm –name bingo_build_code_documentation_container bingo_build_code_documentation
docker cp bingo_build_code_documentation_container:/app/docs/source .
docker container kill bingo_build_code_documentation_container

For the last point, we can deploy documentation at github pages , in a separate folder in docs, named source ( we will just copy the files genetated by docker)

You can find the result of the documentation at

bingo-cards-api

bingo-cards-api-objects

bingo-cards-ui

bingo-meeting-console

bingo-meeting-objects

bingo-meeting-objects-test

Bingo

Now we must code the endpoint to create a meeting. As per the nest.js documentation , we should create a module ,a controller and a service to redirect calls . The problem is that , to create a meeting, we should transmit 2 parameters: userName and meetingName. To do this via  HTTP, we must create a new class with this 2 parameters :

export class CreateMeeting {
  readonly userName: string;
  readonly meetingName: string;
}

Also we want to add Swagger as show at https://docs.nestjs.com/recipes/swagger .  And for this, according to the documentation , we should decorate the class:

import { ApiModelProperty } from '@nestjs/swagger';

export class CreateMeeting {
  @ApiModelProperty()
  readonly userName: string;
  @ApiModelProperty()
  readonly meetingName: string;
}

And now we have a controller with 2 functions – get – to show all meetings – and post-  to create the meeting:

@Controller('meetings')
export class MeetingsController {
    constructor(private meetingsService: MeetingService){}

    @Get()
    index(): Meeting[] {
      return this.meetingsService.meetings;
    }

    @Post()
    async create(@Body() cm: CreateMeeting): Promise<Meeting> {
        console.log(`userName : ${JSON.stringify(cm.userName)}  meetingName: ${JSON.stringify(cm.meetingName)}`);
        return this.meetingsService.create(cm.userName, cm.meetingName);

    }
}

And now we have a fully qualified web api that can create a meeting.  And we have swagger to test functions.

That’s good for a start…

Bingo

Now it is the moment to have our first executable release– console application. First, we want to see if the js obtain by compilation of ts run under node ( it runs under  ts-node index.ts , but it runs under node.js ? ). And we see that , when I run node index.js it gives error “ could not find bingo-meeting-object/MeetingFactory”.

It is clear that, even if yean workspaces works well with node and typescript, the final result, index.js , is not prepared to run under node. Solving the problem is about compiling typescript with project references  . The documentation is at https://www.typescriptlang.org/docs/handbook/project-references.html#composite  , and a sample project can be found at https://github.com/RyanCavanaugh/learn-a

It is composed by

1. having a tsconfig.json with

{

“compilerOptions”: {

“target”: “es5”,

“module”: “commonjs”,

“declaration”: true,

“declarationMap”: true,

“sourceMap”: true,

“strict”: false,

“composite”: true,

“esModuleInterop”: true

}

}

and extending in tsconfig.json

“extends”: “../tsconfig.settings.json”,

2. Compiling the projects with

tsc -b .

3. Creating index.ts with all classes exports

export * from “./MeetingsFactory”;

export * from “./Meeting”;

export * from “./Cards”;

export * from “./Participant”;

And now we can execute index.js with node index.jsinto

That means also the referenced projects are compiled into node_modules. That means that will not run without it.

We want now to create a console executable for the console project. That means something that compiles everything into an exe  – no matter windows , linux , or macos

We use for that https://www.npmjs.com/package/pkg

In the package.json of the console project we put

FROM node:8
WORKDIR /app
COPY . ./
RUN yarn
RUN yarn buildConsole
CMD tail -f /dev/null

docker build .. -f docker_build_console.txt -t bingo_build_console
docker run -d –rm –name bingo_build_console_container bingo_build_console
docker cp bingo_build_console_container:/app/bingo-meeting-console/bingo-meeting-console-win.exe .
docker cp bingo_build_console_container:/app/bingo-meeting-console/bingo-meeting-console-linux .
docker cp bingo_build_console_container:/app/bingo-meeting-console/bingo-meeting-console-macos .
docker container kill bingo_build_console_container