@gapi/schematics 1.8.122

package/src/lib/type/type.factory.test.ts

@@ -0,0 +1,191 @@
+import { normalize } from '@angular-devkit/core';
+import {
+  SchematicTestRunner,
+  UnitTestTree,
+} from '@angular-devkit/schematics/testing';
+import * as path from 'path';
+import { ApplicationOptions } from '../application/application.schema';
+import { ModuleOptions } from '../module/module.schema';
+import { ControllerOptions } from './controller.schema';
+
+describe('Controller Factory', () => {
+  const runner: SchematicTestRunner = new SchematicTestRunner(
+    '.',
+    path.join(process.cwd(), 'src/collection.json'),
+  );
+  it('should manage name only', () => {
+    const options: ControllerOptions = {
+      name: 'foo',
+      skipImport: true,
+      spec: false,
+      flat: false,
+    };
+    const tree: UnitTestTree = runner.runSchematic('controller', options);
+    const files: string[] = tree.files;
+
+    expect(
+      files.find(filename => filename === '/foo/foo.controller.ts'),
+    ).toBeDefined();
+    expect(
+      files.find(filename => filename === '/foo/foo.controller.spec.ts'),
+    ).not.toBeDefined();
+    expect(tree.readContent('/foo/foo.controller.ts')).toEqual(
+      "import { Controller } from '@nestjs/common';\n" +
+        '\n' +
+        "@Controller('foo')\n" +
+        'export class FooController {}\n',
+    );
+  });
+  it('should manage name has a path', () => {
+    const options: ControllerOptions = {
+      name: 'bar/foo',
+      skipImport: true,
+    };
+    const tree: UnitTestTree = runner.runSchematic('controller', options);
+    const files: string[] = tree.files;
+    expect(
+      files.find(filename => filename === '/bar/foo/foo.controller.ts'),
+    ).toBeDefined();
+    expect(
+      files.find(filename => filename === '/bar/foo/foo.controller.spec.ts'),
+    ).toBeDefined();
+    expect(tree.readContent('/bar/foo/foo.controller.ts')).toEqual(
+      "import { Controller } from '@nestjs/common';\n" +
+        '\n' +
+        "@Controller('foo')\n" +
+        'export class FooController {}\n',
+    );
+  });
+  it('should manage name and path', () => {
+    const options: ControllerOptions = {
+      name: 'foo',
+      path: 'bar',
+      skipImport: true,
+    };
+    const tree: UnitTestTree = runner.runSchematic('controller', options);
+    const files: string[] = tree.files;
+    expect(
+      files.find(filename => filename === '/bar/foo/foo.controller.ts'),
+    ).toBeDefined();
+    expect(
+      files.find(filename => filename === '/bar/foo/foo.controller.spec.ts'),
+    ).toBeDefined();
+    expect(tree.readContent('/bar/foo/foo.controller.ts')).toEqual(
+      "import { Controller } from '@nestjs/common';\n" +
+        '\n' +
+        "@Controller('foo')\n" +
+        'export class FooController {}\n',
+    );
+  });
+  it('should manage name to dasherize', () => {
+    const options: ControllerOptions = {
+      name: 'fooBar',
+      skipImport: true,
+    };
+    const tree: UnitTestTree = runner.runSchematic('controller', options);
+    const files: string[] = tree.files;
+    expect(
+      files.find(filename => filename === '/foo-bar/foo-bar.controller.ts'),
+    ).toBeDefined();
+    expect(
+      files.find(
+        filename => filename === '/foo-bar/foo-bar.controller.spec.ts',
+      ),
+    ).toBeDefined();
+    expect(tree.readContent('/foo-bar/foo-bar.controller.ts')).toEqual(
+      "import { Controller } from '@nestjs/common';\n" +
+        '\n' +
+        "@Controller('foo-bar')\n" +
+        'export class FooBarController {}\n',
+    );
+  });
+  it('should manage path to dasherize', () => {
+    const options: ControllerOptions = {
+      name: 'barBaz/foo',
+      skipImport: true,
+    };
+    const tree: UnitTestTree = runner.runSchematic('controller', options);
+    const files: string[] = tree.files;
+    expect(
+      files.find(filename => filename === '/bar-baz/foo/foo.controller.ts'),
+    ).toBeDefined();
+    expect(
+      files.find(
+        filename => filename === '/bar-baz/foo/foo.controller.spec.ts',
+      ),
+    ).toBeDefined();
+    expect(tree.readContent('/bar-baz/foo/foo.controller.ts')).toEqual(
+      "import { Controller } from '@nestjs/common';\n" +
+        '\n' +
+        "@Controller('foo')\n" +
+        'export class FooController {}\n',
+    );
+  });
+  it('should manage javascript file', () => {
+    const options: ControllerOptions = {
+      name: 'foo',
+      language: 'js',
+      skipImport: true,
+    };
+    const tree: UnitTestTree = runner.runSchematic('controller', options);
+    const files: string[] = tree.files;
+    expect(
+      files.find(filename => filename === '/foo/foo.controller.js'),
+    ).toBeDefined();
+    expect(
+      files.find(filename => filename === '/foo/foo.controller.spec.js'),
+    ).toBeDefined();
+    expect(tree.readContent('/foo/foo.controller.js')).toEqual(
+      "import { Controller } from '@nestjs/common';\n" +
+        '\n' +
+        "@Controller('foo')\n" +
+        'export class FooController {}\n',
+    );
+  });
+  it('should manage declaration in app module', () => {
+    const app: ApplicationOptions = {
+      name: '',
+    };
+    let tree: UnitTestTree = runner.runSchematic('application', app);
+    const options: ControllerOptions = {
+      name: 'foo',
+    };
+    tree = runner.runSchematic('controller', options, tree);
+    expect(tree.readContent(normalize('/src/app.module.ts'))).toEqual(
+      "import { Module } from '@nestjs/common';\n" +
+        "import { AppController } from './app.controller';\n" +
+        "import { AppService } from './app.service';\n" +
+        "import { FooController } from './foo/foo.controller';\n" +
+        '\n' +
+        '@Module({\n' +
+        '  imports: [],\n' +
+        '  controllers: [AppController, FooController],\n' +
+        '  providers: [AppService],\n' +
+        '})\n' +
+        'export class AppModule {}\n',
+    );
+  });
+  it('should manage declaration in foo module', () => {
+    const app: ApplicationOptions = {
+      name: '',
+    };
+    let tree: UnitTestTree = runner.runSchematic('application', app);
+    const module: ModuleOptions = {
+      name: 'foo',
+    };
+    tree = runner.runSchematic('module', module, tree);
+    const options: ControllerOptions = {
+      name: 'foo',
+    };
+    tree = runner.runSchematic('controller', options, tree);
+    expect(tree.readContent(normalize('/src/foo/foo.module.ts'))).toEqual(
+      "import { Module } from '@nestjs/common';\n" +
+        "import { FooController } from './foo.controller';\n" +
+        '\n' +
+        '@Module({\n' +
+        '  controllers: [FooController]\n' +
+        '})\n' +
+        'export class FooModule {}\n',
+    );
+  });
+});

package/src/lib/type/type.factory.ts

@@ -0,0 +1,91 @@
+import { join, Path, strings } from '@angular-devkit/core';
+import {
+  apply,
+  branchAndMerge,
+  chain,
+  filter,
+  mergeWith,
+  move,
+  noop,
+  Rule,
+  SchematicContext,
+  template,
+  Tree,
+  url,
+} from '@angular-devkit/schematics';
+import {
+  DeclarationOptions,
+  ModuleDeclarator,
+} from '../../utils/module.declarator';
+import { ModuleFinder } from '../../utils/module.finder';
+import { Location, NameParser } from '../../utils/name.parser';
+import { mergeSourceRoot } from '../../utils/source-root.helpers';
+import { DEFAULT_LANGUAGE } from '../defaults';
+import { ControllerOptions } from './type.schema';
+
+const ELEMENT_METADATA = 'controllers';
+const ELEMENT_TYPE = 'controller';
+
+export function main(options: ControllerOptions): Rule {
+  options = transform(options);
+  return (tree: Tree, context: SchematicContext) => {
+    return branchAndMerge(
+      chain([
+        mergeSourceRoot(options),
+        mergeWith(generate(options)),
+        addDeclarationToModule(options),
+      ]),
+    )(tree, context);
+  };
+}
+
+function transform(source: ControllerOptions): ControllerOptions {
+  const target: ControllerOptions = Object.assign({}, source);
+  target.metadata = ELEMENT_METADATA;
+  target.type = ELEMENT_TYPE;
+
+  const location: Location = new NameParser().parse(target);
+  target.name = strings.dasherize(location.name);
+  target.path = strings.dasherize(location.path);
+  target.language =
+    target.language !== undefined ? target.language : DEFAULT_LANGUAGE;
+
+  target.path = target.flat
+    ? target.path
+    : join(target.path as Path, target.name);
+  return target;
+}
+
+function generate(options: ControllerOptions) {
+  return (context: SchematicContext) =>
+    apply(url(join('./files' as Path, options.language)), [
+      options.spec ? noop() : filter(path => !path.endsWith('.spec.ts')),
+      template({
+        ...strings,
+        ...options,
+      }),
+      move(options.path),
+    ])(context);
+}
+
+function addDeclarationToModule(options: ControllerOptions): Rule {
+  return (tree: Tree) => {
+    if (options.skipImport !== undefined && options.skipImport) {
+      return tree;
+    }
+    options.module = new ModuleFinder(tree).find({
+      name: options.name,
+      path: options.path as Path,
+    });
+    if (!options.module) {
+      return tree;
+    }
+    const content = tree.read(options.module).toString();
+    const declarator: ModuleDeclarator = new ModuleDeclarator();
+    tree.overwrite(
+      options.module,
+      declarator.declare(content, options as DeclarationOptions),
+    );
+    return tree;
+  };
+}

package/src/lib/type/type.schema.d.ts

@@ -0,0 +1,44 @@
+import { Path } from '@angular-devkit/core';
+
+export interface ControllerOptions {
+  /**
+   * The name of the controller.
+   */
+  name: string;
+  /**
+   * The path to create the controller.
+   */
+  path?: string | Path;
+  /**
+   * The path to insert the controller declaration.
+   */
+  module?: Path;
+  /**
+   * Directive to insert declaration in module.
+   */
+  skipImport?: boolean;
+  /**
+   * Metadata name affected by declaration insertion.
+   */
+  metadata?: string;
+  /**
+   * Nest element type name
+   */
+  type?: string;
+  /**
+   * Application language.
+   */
+  language?: string;
+  /**
+   * The source root path
+   */
+  sourceRoot?: string;
+  /**
+   * Specifies if a spec file is generated.
+   */
+  spec?: boolean;
+  /**
+   * Flag to indicate if a directory is created.
+   */
+  flat?: boolean;
+}

package/src/utils/metadata.manager.ts

@@ -0,0 +1,219 @@
+import {
+  ArrayLiteralExpression,
+  CallExpression,
+  createSourceFile,
+  Decorator,
+  Expression,
+  Identifier,
+  Node,
+  NodeArray,
+  ObjectLiteralElement,
+  ObjectLiteralExpression,
+  PropertyAssignment,
+  ScriptTarget,
+  SourceFile,
+  StringLiteral,
+  SyntaxKind,
+} from 'typescript';
+import { DeclarationOptions } from './module.declarator';
+
+export class MetadataManager {
+  constructor(private content: string) {}
+
+  public insert(
+    metadata: string,
+    symbol: string,
+    staticOptions?: DeclarationOptions['staticOptions'],
+  ): string {
+    const source: SourceFile = createSourceFile(
+      'filename.ts',
+      this.content,
+      ScriptTarget.ES2017,
+    );
+    const decoratorNodes: Node[] = this.getDecoratorMetadata(source, '@Module');
+    const node: Node = decoratorNodes[0];
+    const matchingProperties: ObjectLiteralElement[] = (node as ObjectLiteralExpression).properties
+      .filter(prop => prop.kind === SyntaxKind.PropertyAssignment)
+      .filter((prop: PropertyAssignment) => {
+        const name = prop.name;
+        switch (name.kind) {
+          case SyntaxKind.Identifier:
+            return (name as Identifier).getText(source) === metadata;
+          case SyntaxKind.StringLiteral:
+            return (name as StringLiteral).text === metadata;
+          default:
+            return false;
+        }
+      });
+
+    symbol = this.mergeSymbolAndExpr(symbol, staticOptions);
+    const addBlankLinesIfDynamic = () => {
+      symbol = staticOptions ? this.addBlankLines(symbol) : symbol;
+    };
+    if (matchingProperties.length === 0) {
+      const expr = node as ObjectLiteralExpression;
+      if (expr.properties.length === 0) {
+        addBlankLinesIfDynamic();
+        return this.insertMetadataToEmptyModuleDecorator(
+          expr,
+          metadata,
+          symbol,
+        );
+      } else {
+        addBlankLinesIfDynamic();
+        return this.insertNewMetadataToDecorator(
+          expr,
+          source,
+          metadata,
+          symbol,
+        );
+      }
+    } else {
+      return this.insertSymbolToMetadata(
+        source,
+        matchingProperties,
+        symbol,
+        staticOptions,
+      );
+    }
+  }
+
+  private getDecoratorMetadata(source: SourceFile, identifier: string): Node[] {
+    return this.getSourceNodes(source)
+      .filter(
+        node =>
+          node.kind === SyntaxKind.Decorator &&
+          (node as Decorator).expression.kind === SyntaxKind.CallExpression,
+      )
+      .map(node => (node as Decorator).expression as CallExpression)
+      .filter(
+        expr =>
+          expr.arguments[0] &&
+          expr.arguments[0].kind === SyntaxKind.ObjectLiteralExpression,
+      )
+      .map(expr => expr.arguments[0] as ObjectLiteralExpression);
+  }
+
+  private getSourceNodes(sourceFile: SourceFile): Node[] {
+    const nodes: Node[] = [sourceFile];
+    const result = [];
+    while (nodes.length > 0) {
+      const node = nodes.shift();
+      if (node) {
+        result.push(node);
+        if (node.getChildCount(sourceFile) >= 0) {
+          nodes.unshift(...node.getChildren());
+        }
+      }
+    }
+    return result;
+  }
+
+  private insertMetadataToEmptyModuleDecorator(
+    expr: ObjectLiteralExpression,
+    metadata: string,
+    symbol: string,
+  ): string {
+    const position = expr.getEnd() - 1;
+    const toInsert = `  ${metadata}: [${symbol}]`;
+    return this.content.split('').reduce((content, char, index) => {
+      if (index === position) {
+        return `${content}\n${toInsert}\n${char}`;
+      } else {
+        return `${content}${char}`;
+      }
+    }, '');
+  }
+
+  private insertNewMetadataToDecorator(
+    expr: ObjectLiteralExpression,
+    source: SourceFile,
+    metadata: string,
+    symbol: string,
+  ): string {
+    const node = expr.properties[expr.properties.length - 1];
+    const position = node.getEnd();
+    const text = node.getFullText(source);
+    const matches = text.match(/^\r?\n\s*/);
+    let toInsert: string;
+    if (matches.length > 0) {
+      toInsert = `,${matches[0]}${metadata}: [${symbol}]`;
+    } else {
+      toInsert = `, ${metadata}: [${symbol}]`;
+    }
+    return this.content.split('').reduce((content, char, index) => {
+      if (index === position) {
+        return `${content}${toInsert}${char}`;
+      } else {
+        return `${content}${char}`;
+      }
+    }, '');
+  }
+
+  private insertSymbolToMetadata(
+    source: SourceFile,
+    matchingProperties: ObjectLiteralElement[],
+    symbol: string,
+    staticOptions?: DeclarationOptions['staticOptions'],
+  ): string {
+    const assignment = matchingProperties[0] as PropertyAssignment;
+    let node: Node | NodeArray<Expression>;
+    const arrLiteral = assignment.initializer as ArrayLiteralExpression;
+    if (arrLiteral.elements.length === 0) {
+      node = arrLiteral;
+    } else {
+      node = arrLiteral.elements;
+    }
+    if (Array.isArray(node)) {
+      const nodeArray = (node as {}) as Node[];
+      const symbolsArray = nodeArray.map(childNode =>
+        childNode.getText(source),
+      );
+      if (symbolsArray.includes(symbol)) {
+        return this.content;
+      }
+      node = node[node.length - 1];
+    }
+    let toInsert: string;
+    let position = (node as Node).getEnd();
+
+    if ((node as Node).kind === SyntaxKind.ArrayLiteralExpression) {
+      position--;
+      toInsert = staticOptions ? this.addBlankLines(symbol) : `${symbol}`;
+    } else {
+      const text = (node as Node).getFullText(source);
+      if (text.match(/^\r?\n/)) {
+        toInsert = `,${text.match(/^\r?\n(\r?)\s+/)[0]}${symbol}`;
+      } else {
+        toInsert = `, ${symbol}`;
+      }
+    }
+    return this.content.split('').reduce((content, char, index) => {
+      if (index === position) {
+        return `${content}${toInsert}${char}`;
+      } else {
+        return `${content}${char}`;
+      }
+    }, '');
+  }
+
+  private mergeSymbolAndExpr(
+    symbol: string,
+    staticOptions?: DeclarationOptions['staticOptions'],
+  ): string {
+    if (!staticOptions) {
+      return symbol;
+    }
+    const spacing = 6;
+    let options = JSON.stringify(staticOptions.value, null, spacing);
+    options = options.replace(/\"([^(\")"]+)\":/g, '$1:');
+    options = options.replace(/\"/g, `'`);
+    options = options.slice(0, options.length - 1) + '    }';
+    symbol += `.${staticOptions.name}(${options})`;
+    return symbol;
+  }
+
+  private addBlankLines(expr: string): string {
+    return `\n    ${expr}\n  `;
+  }
+}