Feature: Extension loader

package.json

@@ -56,6 +56,7 @@
     "from2": "^2.3.0",
     "jest": "27.5.1",
     "nx": "14.0.3",
+    "pg-mem": "^2.6.3",
     "prettier": "^2.5.1",
     "supertest": "^6.2.3",
     "ts-essentials": "^9.1.2",

packages/build/src/containers/container.ts

@@ -1,25 +1,39 @@
 import { Container as InversifyContainer } from 'inversify';
 import { Container as CoreContainer } from '@vulcan-sql/core';
 import { IBuildOptions } from '@vulcan-sql/build/models';
-import { schemaParserModule } from './modules';
+import {
+  documentGeneratorModule,
+  extensionModule,
+  schemaParserModule,
+} from './modules';
 
 export class Container {
-  private inversifyContainer = new InversifyContainer();
+  private inversifyContainer?: InversifyContainer;
+  private coreContainer?: CoreContainer;
 
   public get<T>(type: symbol) {
-    return this.inversifyContainer.get<T>(type);
+    const instance = this.inversifyContainer?.get<T>(type);
+    if (!instance)
+      throw new Error(`Cannot resolve ${type.toString()} in container`);
+    return instance;
   }
 
   public async load(options: IBuildOptions) {
-    const coreContainer = new CoreContainer();
-    await coreContainer.load(options);
-    this.inversifyContainer.parent = coreContainer.getInversifyContainer();
-    this.inversifyContainer.load(schemaParserModule(options.schemaParser));
+    this.coreContainer = new CoreContainer();
+    await this.coreContainer.load(options);
+    this.inversifyContainer = this.coreContainer.getInversifyContainer();
+    await this.inversifyContainer.loadAsync(
+      schemaParserModule(options['schema-parser'])
+    );
+    await this.inversifyContainer.loadAsync(extensionModule(options));
+    await this.inversifyContainer.loadAsync(
+      documentGeneratorModule(options['document-generator'])
+    );
   }
 
-  public unload() {
-    this.inversifyContainer.parent?.unbindAll();
-    this.inversifyContainer.unbindAll();
+  public async unload() {
+    await this.coreContainer?.unload();
+    await this.inversifyContainer?.unbindAllAsync();
   }
 
   public getInversifyContainer() {

packages/build/src/containers/index.ts

@@ -1,3 +1,4 @@
 import 'reflect-metadata';
 export * from './types';
 export * from './container';
+export * from './modules';

packages/build/src/containers/modules/documentGenerator.ts

@@ -0,0 +1,25 @@
+import {
+  IDocumentGeneratorOptions,
+  SpecGenerator,
+} from '@vulcan-sql/build/models';
+import { AsyncContainerModule, interfaces } from 'inversify';
+import { DocumentGenerator } from '../../lib/document-generator';
+import { DocumentGeneratorOptions } from '../../options/documentGenerator';
+import { TYPES } from '../types';
+
+export const documentGeneratorModule = (options?: IDocumentGeneratorOptions) =>
+  new AsyncContainerModule(async (bind) => {
+    // Options
+    bind<IDocumentGeneratorOptions>(
+      TYPES.DocumentGeneratorInputOptions
+    ).toConstantValue(options || ({} as any));
+    bind<IDocumentGeneratorOptions>(TYPES.DocumentGeneratorOptions)
+      .to(DocumentGeneratorOptions)
+      .inSingletonScope();
+
+    // Document generator
+    bind<DocumentGenerator>(TYPES.DocumentGenerator).to(DocumentGenerator);
+    bind<interfaces.AutoNamedFactory<SpecGenerator>>(
+      TYPES.Factory_SpecGenerator
+    ).toAutoNamedFactory(TYPES.Extension_SpecGenerator);
+  });

packages/build/src/containers/modules/extension.ts

@@ -0,0 +1,19 @@
+import { builtInSchemaReader } from '@vulcan-sql/build/schema-parser';
+import { ExtensionLoader } from '@vulcan-sql/core';
+import { AsyncContainerModule } from 'inversify';
+import { builtInSpecGenerator } from '../../lib/document-generator';
+import { IBuildOptions } from '../../models/buildOptions';
+
+export const extensionModule = (options: IBuildOptions) =>
+  new AsyncContainerModule(async (bind) => {
+    const loader = new ExtensionLoader(options);
+    // Internal extension modules
+
+    // Schema reader
+    loader.loadInternalExtensionModule(builtInSchemaReader);
+
+    // Spec generator
+    loader.loadInternalExtensionModule(builtInSpecGenerator);
+
+    loader.bindExtensions(bind);
+  });

packages/build/src/containers/modules/index.ts

@@ -1 +1,3 @@
 export * from './schemaParser';
+export * from './extension';
+export * from './documentGenerator';

packages/build/src/containers/modules/schemaParser.ts

@@ -1,42 +1,44 @@
-import {
-  ISchemaParserOptions,
-  SchemaReaderType,
-} from '@vulcan-sql/build/models';
-import {
-  FileSchemaReader,
-  SchemaParser,
-  SchemaReader,
-} from '@vulcan-sql/build/schema-parser';
-import { ContainerModule, interfaces } from 'inversify';
+import { ISchemaParserOptions, SchemaReader } from '@vulcan-sql/build/models';
+import { SchemaParser } from '@vulcan-sql/build/schema-parser';
+import { AsyncContainerModule, interfaces } from 'inversify';
 import { SchemaParserOptions } from '../../options/schemaParser';
 import { TYPES } from '../types';
-import { SchemaParserMiddlewares } from '@vulcan-sql/build/schema-parser/middleware';
+import {
+  SchemaParserMiddleware,
+  SchemaParserMiddlewares,
+} from '@vulcan-sql/build/schema-parser/middleware';
 
-export const schemaParserModule = (options: ISchemaParserOptions) =>
-  new ContainerModule((bind) => {
+export const schemaParserModule = (options?: ISchemaParserOptions) =>
+  new AsyncContainerModule(async (bind) => {
     // Options
     bind<ISchemaParserOptions>(TYPES.SchemaParserInputOptions).toConstantValue(
-      options
+      options || ({} as any)
     );
     bind<SchemaParserOptions>(TYPES.SchemaParserOptions)
       .to(SchemaParserOptions)
       .inSingletonScope();
 
     // Schema reader
     bind<SchemaReader>(TYPES.SchemaReader)
-      .to(FileSchemaReader)
-      .inSingletonScope()
-      .whenTargetNamed(SchemaReaderType.LocalFile);
-
+      .toDynamicValue((context) => {
+        const factory = context.container.get<
+          interfaces.AutoNamedFactory<SchemaReader>
+        >(TYPES.Factory_SchemaReader);
+        const options = context.container.get<SchemaParserOptions>(
+          TYPES.SchemaParserOptions
+        );
+        return factory(options.reader);
+      })
+      .inSingletonScope();
     bind<interfaces.AutoNamedFactory<SchemaReader>>(
       TYPES.Factory_SchemaReader
-    ).toAutoNamedFactory<SchemaReader>(TYPES.SchemaReader);
+    ).toAutoNamedFactory<SchemaReader>(TYPES.Extension_SchemaReader);
 
     // Schema parser
     bind<SchemaParser>(TYPES.SchemaParser).to(SchemaParser).inSingletonScope();
 
     // Middleware
     for (const middleware of SchemaParserMiddlewares) {
-      bind(TYPES.SchemaParserMiddleware).to(middleware);
+      bind<SchemaParserMiddleware>(TYPES.SchemaParserMiddleware).to(middleware);
     }
   });

packages/build/src/containers/types.ts

@@ -1,8 +1,17 @@
 export const TYPES = {
+  // Schema
   SchemaParserInputOptions: Symbol.for('SchemaParserInputOptions'),
   SchemaParserOptions: Symbol.for('SchemaParserOptions'),
   SchemaReader: Symbol.for('SchemaReader'),
   Factory_SchemaReader: Symbol.for('Factory_SchemaReader'),
   SchemaParser: Symbol.for('SchemaParser'),
   SchemaParserMiddleware: Symbol.for('SchemaParserMiddleware'),
+  // Document
+  DocumentGenerator: Symbol.for('DocumentGenerator'),
+  DocumentGeneratorInputOptions: Symbol.for('DocumentGeneratorInputOptions'),
+  DocumentGeneratorOptions: Symbol.for('DocumentGeneratorOptions'),
+  Factory_SpecGenerator: Symbol.for('Factory_SpecGenerator'),
+  // Extension
+  Extension_SchemaReader: Symbol.for('Extension_SchemaReader'),
+  Extension_SpecGenerator: Symbol.for('Extension_SpecGenerator'),
 };

packages/build/src/lib/document-generator/documentGenerator.ts

@@ -0,0 +1,37 @@
+import { APISchema } from '@vulcan-sql/core';
+import { inject, injectable, interfaces } from 'inversify';
+import { TYPES } from '../../containers/types';
+import { SpecGenerator } from '../../models/extensions';
+import { DocumentGeneratorOptions } from '../../options/documentGenerator';
+import * as jsYAML from 'js-yaml';
+import * as path from 'path';
+import { promises as fs } from 'fs';
+
+@injectable()
+export class DocumentGenerator {
+  private specGenerators: SpecGenerator[];
+  private folderPath: string;
+
+  constructor(
+    @inject(TYPES.Factory_SpecGenerator)
+    specGeneratorFactory: interfaces.AutoNamedFactory<SpecGenerator>,
+    @inject(TYPES.DocumentGeneratorOptions) options: DocumentGeneratorOptions
+  ) {
+    this.specGenerators = [];
+    for (const spec of options.specs) {
+      this.specGenerators.push(specGeneratorFactory(spec));
+    }
+    this.folderPath = options.folderPath;
+  }
+
+  public async generateDocuments(schemas: APISchema[]) {
+    for (const generator of this.specGenerators) {
+      const spec = generator.getSpec(schemas);
+      const filePath = path.resolve(
+        this.folderPath,
+        `spec-${generator.getExtensionId()}.yaml`
+      );
+      await fs.writeFile(filePath, jsYAML.dump(spec), 'utf-8');
+    }
+  }
+}

packages/build/src/lib/document-generator/index.ts

@@ -0,0 +1,2 @@
+export * from './spec-generator';
+export * from './documentGenerator';

packages/build/src/lib/document-generator/spec-generator/index.ts

@@ -0,0 +1,4 @@
+import { OAS3SpecGenerator } from './oas3';
+export const builtInSpecGenerator = [OAS3SpecGenerator];
+
+export * from './oas3';

packages/build/src/lib/spec-generator/oas3/oas3SpecGenerator.ts → packages/build/src/lib/document-generator/spec-generator/oas3/oas3SpecGenerator.ts

@@ -1,4 +1,4 @@
-import { SpecGenerator } from '../specGenerator';
+import { SpecGenerator } from '../../../../models/extensions/specGenerator';
 import * as oas3 from 'openapi3-ts';
 import {
   APISchema,
@@ -14,19 +14,24 @@ import {
   RequestSchema as RequestParameter,
   RequiredConstraint,
   ResponseProperty,
+  VulcanExtensionId,
+  VulcanInternalExtension,
 } from '@vulcan-sql/core';
 import { isEmpty } from 'lodash';
+import { DocumentGeneratorSpec } from '@vulcan-sql/build/models';
 
+@VulcanInternalExtension()
+@VulcanExtensionId(DocumentGeneratorSpec.oas3)
 export class OAS3SpecGenerator extends SpecGenerator<oas3.OpenAPIObject> {
   // Follow the OpenAPI specification version 3.0.3
   // see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md
   private oaiVersion = '3.0.3';
 
-  public getSpec() {
+  public getSpec(schemas: APISchema[]) {
     const spec: oas3.OpenAPIObject = {
       openapi: this.getOAIVersion(),
       info: this.getInfo(),
-      paths: this.getPaths(),
+      paths: this.getPaths(schemas),
     };
     return spec;
   }
@@ -43,9 +48,8 @@ export class OAS3SpecGenerator extends SpecGenerator<oas3.OpenAPIObject> {
     };
   }
 
-  private getPaths(): oas3.PathsObject {
+  private getPaths(schemas: APISchema[]): oas3.PathsObject {
     const paths: oas3.PathsObject = {};
-    const schemas = this.getSchemas();
     for (const schema of schemas) {
       paths[this.convertToOASPath(schema.urlPath)] = this.getPath(schema);
     }

packages/build/src/lib/schema-parser/middleware/checkValidator.ts

@@ -29,7 +29,9 @@ export class CheckValidator extends SchemaParserMiddleware {
         throw new Error('Validator name is required');
       }
 
-      const validator = await this.validatorLoader.load(validatorRequest.name);
+      const validator = this.validatorLoader.getValidator(
+        validatorRequest.name
+      );
 
       // TODO: indicate the detail of error
       validator.validateSchema(validatorRequest.args);

packages/build/src/lib/schema-parser/middleware/setConstraints.ts

@@ -25,7 +25,7 @@ export class SetConstraints extends SchemaParserMiddleware {
       // load validator and keep args
       const validatorsWithArgs = await Promise.all(
         (request.validators || []).map(async (validator) => ({
-          validator: await this.validatorLoader.load(validator.name),
+          validator: this.validatorLoader.getValidator(validator.name),
           args: validator.args,
         }))
       );

packages/build/src/lib/schema-parser/schema-reader/fileSchemaReader.ts

@@ -1,28 +1,46 @@
-import { SchemaFormat, SchemaData, SchemaReader } from './schemaReader';
+import {
+  SchemaFormat,
+  SchemaData,
+  SchemaReader,
+  SchemaReaderType,
+} from '@vulcan-sql/build/models';
 import * as glob from 'glob';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { inject, injectable } from 'inversify';
-import { TYPES } from '@vulcan-sql/build/containers';
 import { SchemaParserOptions } from '@vulcan-sql/build/options';
+import {
+  VulcanExtensionId,
+  VulcanInternalExtension,
+  TYPES as CORE_TYPES,
+} from '@vulcan-sql/core';
+import { inject } from 'inversify';
+import { TYPES } from '@vulcan-sql/build/containers';
 
 export interface FileSchemaReaderOptions {
   folderPath: string;
 }
 
-@injectable()
-export class FileSchemaReader implements SchemaReader {
+@VulcanInternalExtension()
+@VulcanExtensionId(SchemaReaderType.LocalFile)
+export class FileSchemaReader extends SchemaReader {
   private options: SchemaParserOptions;
 
-  constructor(@inject(TYPES.SchemaParserOptions) options: SchemaParserOptions) {
+  constructor(
+    @inject(TYPES.SchemaParserOptions) options: SchemaParserOptions,
+    @inject(CORE_TYPES.ExtensionConfig) config: any,
+    @inject(CORE_TYPES.ExtensionName) moduleName: string
+  ) {
+    super(config, moduleName);
     this.options = options;
   }
 
   public async *readSchema(): AsyncGenerator<SchemaData> {
+    if (!this.options?.folderPath)
+      throw new Error(`Config schema-parser.folderPath must be defined`);
     const files = await this.getSchemaFilePaths();
 
     for (const file of files) {
-      const fileName = path.relative(this.options.folderPath, file);
+      const fileName = path.relative(this.options!.folderPath, file);
       const { ext } = path.parse(fileName);
       const sourceName = fileName.replace(new RegExp(`\\${ext}$`), '');
       yield {
@@ -36,7 +54,7 @@ export class FileSchemaReader implements SchemaReader {
   private async getSchemaFilePaths(): Promise<string[]> {
     return new Promise((resolve, reject) => {
       glob(
-        path.resolve(this.options.folderPath, '**', '*.yaml'),
+        path.resolve(this.options!.folderPath, '**', '*.yaml'),
         { nodir: true },
         (err, files) => {
           if (err) return reject(err);

packages/build/src/lib/schema-parser/schema-reader/index.ts

@@ -1,2 +1,4 @@
-export * from './schemaReader';
+import { FileSchemaReader } from './fileSchemaReader';
+export const builtInSchemaReader = [FileSchemaReader];
+
 export * from './fileSchemaReader';