PTF-1276: Updated local launch

Author: denismukhopadov

package.json

@@ -1,7 +1,7 @@
 {
   "name": "codestore",
   "description": "code.store CLI. Add services, deploy, debug, perform all operations from your terminal.",
-  "version": "1.4.15",
+  "version": "1.5.0",
   "bin": {
     "codestore": "./bin/run",
     "cs": "./bin/run"
@@ -27,11 +27,13 @@
     "@types/inquirer": "^6.5.0",
     "@types/jest": "^25.2.1",
     "apollo-boost": "^0.4.7",
+    "apollo-server-express": "^2.16.1",
     "archiver-promise": "^1.0.0",
     "axios": "^0.19.2",
     "chalk": "^3.0.0",
     "clear": "^0.1.0",
     "cli-ux": "^5.4.5",
+    "codestore-utils": "^1.1.2",
     "completion": "^1.0.1",
     "cross-fetch": "^3.0.4",
     "enquirer": "^2.3.5",
@@ -44,10 +46,12 @@
     "open": "^7.0.3",
     "ora": "^4.0.3",
     "os": "^0.1.1",
+    "pg": "^8.3.0",
     "rimraf": "^3.0.2",
     "tabtab": "^3.0.2",
     "tree-node-cli": "^1.3.0",
     "ts-jest": "^25.3.1",
+    "typeorm": "^0.2.25",
     "unzipper": "^0.10.11",
     "yaml": "^1.10.0",
     "zip-a-folder": "0.0.12"
@@ -66,7 +70,7 @@
     "nyc": "^14.1.1",
     "ts-node": "^8.6.2",
     "tsconfig-paths": "^3.9.0",
-    "typescript": "^3.8.3"
+    "typescript": "^3.9.7"
   },
   "engines": {
     "node": ">=8.0.0"

src/commands/service/create.ts

@@ -7,7 +7,6 @@ import Command from '../../lib/command';
 import { IServiceCreate } from '../../interfaces/service.interface';
 import { createPrefix } from '../../common/utils';
 import FileWorker from '../../common/file-worker';
-import { installDependencies } from '../../lib/child-cli';
 
 interface Ctx {
   service: {
@@ -152,12 +151,6 @@ export default class Create extends Command {
         this.structure = tree(uniqueName, { exclude: [/node_modules/, /dist/] });
       },
     },
-    {
-      title: 'Installing dependencies',
-      task: async (ctx): Promise<void> => {
-        await installDependencies(ctx.service.uniqueName);
-      },
-    },
     ]);
 
     await tasks.run();

src/commands/service/dev.ts

@@ -0,0 +1,50 @@
+import { logger } from 'codestore-utils';
+import { Listr, ListrTask } from 'listr2';
+import Command from '../../lib/command';
+import { bootstrap } from '../../lib/launcher';
+import { installDependencies } from '../../lib/child-cli';
+import compile from '../../lib/compiler';
+
+export const flow = (context: { localConfiguration; command: Command}): ListrTask[] => [
+  {
+    title: 'Installing dependencies',
+    task: async (): Promise<void> => {
+      await installDependencies();
+    },
+  },
+  {
+    title: 'Compiling code',
+    task: async (): Promise<void> => {
+      await compile(await context.command.serviceWorker.loadResolversPaths(), context.command);
+    },
+  },
+];
+
+export default class Dev extends Command {
+  public static description = 'Launch your service locally';
+
+  public static aliases = ['dev'];
+
+  public async execute(): Promise<void> {
+    const { localConfiguration } = await this.serviceWorker.loadValuesFromYaml();
+
+    if (!localConfiguration) {
+      throw new Error('Cannot find localConfiguration in codestore.yaml');
+    }
+
+    if (!localConfiguration || !localConfiguration.database) {
+      throw new Error('There is no database configuration in codestore.yaml');
+    }
+
+    await new Listr<{}>(flow({ localConfiguration, command: this })).run();
+
+    const { database, application } = localConfiguration;
+
+    logger.log('Starting development server');
+
+    await bootstrap({
+      db: database,
+      port: application.port,
+    });
+  }
+}

src/commands/service/generate.ts

@@ -1,13 +1,11 @@
 import { Listr, ListrTask } from 'listr2';
-import { yellow } from 'chalk';
 import clear from 'clear';
 import Command from '../../lib/command';
 import Aliases from '../../common/constants/aliases';
 import FileWorker from '../../common/file-worker';
 import PromisifiedFs from '../../common/promisified-fs';
 import Paths from '../../common/constants/paths';
-import { revertMigration, runMigration, compile } from '../../lib/child-cli';
-import Logger from '../../lib/logger';
+import compile from '../../lib/compiler';
 
 const firstLine = (str: string): string => str.split('\n')[0].replace(/:$/, '');
 
@@ -22,7 +20,7 @@ export const generateFlow = (context: Command, error: (input: string | Error, op
     title: 'Compiling your code',
     task: async (): Promise<void> => {
       await PromisifiedFs.rimraf(Paths.DIST);
-      await compile();
+      await compile(await context.serviceWorker.loadResolversPaths(), context);
     },
   },
   {
@@ -33,7 +31,7 @@ export const generateFlow = (context: Command, error: (input: string | Error, op
       ctx.encodedZip = await FileWorker.zipFolder();
     },
   },
-  {
+  /* {
     title: 'Reverting extra migrations',
     task: async (ctx, task): Promise<void> => {
       const currentMigrations = await PromisifiedFs.readdir(Paths.MIGRATIONS);
@@ -52,10 +50,11 @@ export const generateFlow = (context: Command, error: (input: string | Error, op
         // eslint-disable-next-line no-param-reassign
         task.title = 'Extra migrations were successfully reverted';
       } catch (e) {
+        console.log(e);
         task.skip(`Migrations were not reverted: ${firstLine(e.toString())}`);
       }
     },
-  },
+  }, */
   {
     title: 'Uploading service to the generator',
     task: async (ctx): Promise<void> => {
@@ -75,13 +74,13 @@ export const generateFlow = (context: Command, error: (input: string | Error, op
       await PromisifiedFs.rimraf(Paths.ENTITIES);
       await PromisifiedFs.rimraf(Paths.DIST);
       await FileWorker.saveZipFromB64(generated, Paths.DATA);
-      await compile();
+      await compile(await context.serviceWorker.loadResolversPaths(), context);
 
       // eslint-disable-next-line no-param-reassign
       task.title = 'Generated code has been saved';
     },
   },
-  {
+  /* {
     title: 'Running generated migration',
     task: async (ctx, task): Promise<void> => {
       try {
@@ -93,7 +92,7 @@ export const generateFlow = (context: Command, error: (input: string | Error, op
         task.skip(`Migrations were not ran: ${firstLine(e.toString())}`);
       }
     },
-  },
+  }, */
 ];
 
 export default class Generate extends Command {

src/interfaces/service-config.interface.ts

@@ -1,3 +1,19 @@
+interface IDbConfig {
+  port: number;
+  username: string;
+  password: string;
+  host: string;
+  database: string;
+}
+
+interface IApplicationConfig {
+  port: number;
+}
+
 export default interface IServiceConfig {
   serviceId: number;
+  localConfiguration: {
+    database: IDbConfig;
+    application: IApplicationConfig;
+  };
 }

src/lib/api-client.ts

@@ -36,6 +36,8 @@ export default class APIClient {
   }
 
   public async loginWeb(): Promise<any> {
+    await this.homeFolderService.removeToken();
+
     // opening browser. See openBrowser.ts for change configurations
     await openBrowser();
     return new Promise((resolve, reject) => {

src/lib/child-cli/child-cli.ts

@@ -18,7 +18,7 @@ const runMigration = (): Promise<void> => runCommand('npm run migration:run');
 
 const revertMigration = (): Promise<void> => runCommand('npm run migration:revert');
 
-const installDependencies = (serviceName: string): Promise<void> => runCommand(`cd ${serviceName} && npm install`);
+const installDependencies = (serviceName?: string): Promise<void> => (serviceName ? runCommand(`cd ${serviceName} && npm install`) : runCommand('npm install'));
 
 export {
   compile,

src/lib/compiler.ts

@@ -0,0 +1,36 @@
+import { join } from 'path';
+import * as ts from 'typescript';
+import Command from './command';
+import PromisifiedFs from '../common/promisified-fs';
+
+export default async (files: any, command: Command): Promise<void> => {
+  const program = ts.createProgram(files, {
+    declaration: true,
+    importHelpers: true,
+    module: 1, // commonjs
+    target: 4, // es2017
+    esModuleInterop: true,
+    strictNullChecks: true,
+    emitDecoratorMetadata: true,
+    experimentalDecorators: true,
+    strict: false,
+    outDir: 'temp',
+  });
+  const emitResult = program.emit();
+
+  const allDiagnostics = ts
+    .getPreEmitDiagnostics(program)
+    .concat(emitResult.diagnostics);
+
+  allDiagnostics.forEach((diagnostic) => {
+    if (diagnostic.file) {
+      const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start!);
+      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+      command.error(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+    } else {
+      command.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+    }
+  });
+
+  await PromisifiedFs.rimraf(join(process.cwd(), 'temp'));
+};

src/lib/launcher/Application.ts

@@ -0,0 +1,36 @@
+import { ApolloServer } from 'apollo-server-express';
+import GraphqlLoader from './GraphQLLoader';
+import DatabaseLoader from './DatabaseLoader';
+import { IConfig } from './interfaces/config.interface';
+
+export default class Application {
+  private gqlLoader: GraphqlLoader = new GraphqlLoader();
+
+  private dbLoader: DatabaseLoader;
+
+  public constructor(public readonly config: IConfig) {
+    this.dbLoader = new DatabaseLoader(config);
+  }
+
+  public async buildServer(): Promise<ApolloServer> {
+    try {
+      const { connection, repositories }: any = await this.dbLoader.getDbConnector();
+
+      return new ApolloServer({
+        playground: true,
+        introspection: true,
+        typeDefs: await this.gqlLoader.getTypeDefs(),
+        resolvers: await this.gqlLoader.getResolvers(),
+        uploads: false,
+        context: (): object => ({
+          db: {
+            connection,
+            repositories,
+          },
+        }),
+      });
+    } catch (e) {
+      throw new Error(`Server failed to start, error: ${e}`);
+    }
+  }
+}

src/lib/launcher/DatabaseLoader.ts

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import { createConnection, Connection } from 'typeorm';
+import path from 'path';
+import { logger } from 'codestore-utils';
+import { IRepositories, IConnector } from './interfaces/database.interface';
+import { IConfig } from './interfaces/config.interface';
+
+export default class DatabaseConnector {
+  private entitiesPath = path.join(process.cwd(), 'src', 'data', 'entities', '*.ts');
+
+  private migrationsPath = path.join(process.cwd(), 'src', 'data', 'migrations', '*.ts');
+
+  public constructor(private readonly config: IConfig) {
+  }
+
+  public async getDbConnector(): Promise<IConnector> {
+    const connection = await this.createConnection();
+    const repositories = await this.loadModels(connection);
+
+    const context = this.constructor.name;
+    logger.log(`Loaded entities: ${Object.keys(repositories)}`, context);
+
+    return {
+      connection,
+      repositories,
+    };
+  }
+
+  private async createConnection(): Promise<Connection> {
+    const context = this.constructor.name;
+
+    logger.log('Connecting to database', context);
+
+    const connection = await createConnection({
+      type: 'postgres',
+      ...this.config.db,
+      entities: [
+        path.normalize(this.entitiesPath),
+      ],
+      migrations: [this.migrationsPath],
+      name: 'default',
+    });
+
+    logger.log(`Successfully connected to database ${this.config.db.database}`, context);
+
+    logger.log('Running migrations', context);
+    try {
+      await connection.runMigrations();
+    } catch (e) {
+      await connection.undoLastMigration();
+      await connection.runMigrations();
+    }
+
+    return connection;
+  }
+
+  private async loadModels(connection: Connection): Promise<IRepositories> {
+    let modelFiles;
+    try {
+      modelFiles = fs.readdirSync(path.join(process.cwd(), 'src', 'data', 'entities'))
+        .filter((file) => /.ts$/.test(file))
+        .map(async (modelFile) => import(`${path.join(process.cwd(), 'src', 'data', 'entities')}/${modelFile}`));
+    } catch (e) {
+      if (e?.code !== 'ENOENT') {
+        logger.error(e, undefined, this.constructor.name);
+      }
+      return {};
+    }
+
+    const loadedEntities = await Promise.all(modelFiles) as any[];
+
+    return loadedEntities.reduce((prev, next) => {
+      const value: any = Object.values(next)[0];
+      const { name } = value;
+
+      return {
+        ...prev,
+        [name]: connection.getRepository(value),
+      };
+    }, {});
+  }
+}