@rxdi/schematics 0.7.124 → 0.7.128

package/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  `;
+  }
+}

package/utils/module-import.declarator.js

@@ -26,10 +26,10 @@ class ModuleImportDeclarator {
     computeRelativePath(options) {
         let importModulePath;
         if (options.type !== undefined) {
-            importModulePath = core_1.normalize(`/${options.path}/${options.name}.${options.type}`);
+            importModulePath = (0, core_1.normalize)(`/${options.path}/${options.name}.${options.type}`);
         }
         else {
-            importModulePath = core_1.normalize(`/${options.path}/${options.name}`);
+            importModulePath = (0, core_1.normalize)(`/${options.path}/${options.name}`);
         }
         return this.solver.relative(options.module, importModulePath);
     }

package/utils/module-import.declarator.ts

@@ -0,0 +1,41 @@
+import { normalize, Path } from '@angular-devkit/core';
+import { DeclarationOptions } from './module.declarator';
+import { PathSolver } from './path.solver';
+
+export class ModuleImportDeclarator {
+  constructor(private solver: PathSolver = new PathSolver()) {}
+
+  public declare(content: string, options: DeclarationOptions): string {
+    const toInsert: string = this.buildLineToInsert(options);
+    const importLines: string[] = this.findImports(content);
+    const otherLines: string[] = this.findOtherLines(content, importLines);
+    importLines.push(toInsert);
+    return importLines.join('\n').concat(otherLines.join('\n'));
+  }
+
+  private findImports(content: string): string[] {
+    return content.split('\n').filter(line => line.match(/import {/));
+  }
+
+  private findOtherLines(content: string, importLines: string[]) {
+    return content.split('\n').filter(line => importLines.indexOf(line) < 0);
+  }
+
+  private buildLineToInsert(options: DeclarationOptions): string {
+    return `import { ${options.symbol} } from '${this.computeRelativePath(
+      options,
+    )}';\n`;
+  }
+
+  private computeRelativePath(options: DeclarationOptions): string {
+    let importModulePath: Path;
+    if (options.type !== undefined) {
+      importModulePath = normalize(
+        `/${options.path}/${options.name}.${options.type}`,
+      );
+    } else {
+      importModulePath = normalize(`/${options.path}/${options.name}`);
+    }
+    return this.solver.relative(options.module, importModulePath);
+  }
+}

package/utils/module-metadata.declarator.ts

@@ -0,0 +1,14 @@
+import { MetadataManager } from './metadata.manager';
+import { DeclarationOptions } from './module.declarator';
+
+export class ModuleMetadataDeclarator {
+  public declare(content: string, options: DeclarationOptions): string {
+    const manager = new MetadataManager(content);
+    const inserted = manager.insert(
+      options.metadata,
+      options.symbol,
+      options.staticOptions,
+    );
+    return inserted;
+  }
+}

package/utils/module.declarator.js

@@ -18,10 +18,10 @@ class ModuleDeclarator {
     computeSymbol(options) {
         const target = Object.assign({}, options);
         if (options.type !== undefined) {
-            target.symbol = strings_1.classify(options.name).concat(strings_1.capitalize(options.type));
+            target.symbol = (0, strings_1.classify)(options.name).concat((0, strings_1.capitalize)(options.type));
         }
         else {
-            target.symbol = strings_1.classify(options.name);
+            target.symbol = (0, strings_1.classify)(options.name);
         }
         return target;
     }

package/utils/module.declarator.ts

@@ -0,0 +1,41 @@
+import { Path } from '@angular-devkit/core';
+import { capitalize, classify } from '@angular-devkit/core/src/utils/strings';
+import { ModuleImportDeclarator } from './module-import.declarator';
+import { ModuleMetadataDeclarator } from './module-metadata.declarator';
+
+export interface DeclarationOptions {
+  metadata: string;
+  type?: string;
+  name: string;
+  path: Path;
+  module: Path;
+  symbol?: string;
+  staticOptions?: {
+    name: string;
+    value: Record<string, any>;
+  };
+}
+
+export class ModuleDeclarator {
+  constructor(
+    private imports: ModuleImportDeclarator = new ModuleImportDeclarator(),
+    private metadata: ModuleMetadataDeclarator = new ModuleMetadataDeclarator(),
+  ) {}
+
+  public declare(content: string, options: DeclarationOptions): string {
+    options = this.computeSymbol(options);
+    content = this.imports.declare(content, options);
+    content = this.metadata.declare(content, options);
+    return content;
+  }
+
+  private computeSymbol(options: DeclarationOptions): DeclarationOptions {
+    const target = Object.assign({}, options);
+    if (options.type !== undefined) {
+      target.symbol = classify(options.name).concat(capitalize(options.type));
+    } else {
+      target.symbol = classify(options.name);
+    }
+    return target;
+  }
+}

package/utils/module.finder.js

@@ -17,7 +17,7 @@ class ModuleFinder {
         }
         const moduleFilename = directory.subfiles.find(filename => /\.module\.(t|j)s/.test(filename));
         return moduleFilename !== undefined
-            ? core_1.join(directory.path, moduleFilename.valueOf())
+            ? (0, core_1.join)(directory.path, moduleFilename.valueOf())
             : this.findIn(directory.parent);
     }
 }

package/utils/module.finder.ts

@@ -0,0 +1,32 @@
+import { join, Path, PathFragment } from '@angular-devkit/core';
+import { DirEntry, Tree } from '@angular-devkit/schematics';
+
+export interface FindOptions {
+  name?: string;
+  path: Path;
+  kind?: string;
+}
+
+export class ModuleFinder {
+  constructor(private tree: Tree) {}
+
+  public find(options: FindOptions): Path | null {
+    const generatedDirectoryPath: Path = options.path;
+    const generatedDirectory: DirEntry = this.tree.getDir(
+      generatedDirectoryPath,
+    );
+    return this.findIn(generatedDirectory);
+  }
+
+  private findIn(directory: DirEntry): Path | null {
+    if (!directory) {
+      return null;
+    }
+    const moduleFilename: PathFragment = directory.subfiles.find(filename =>
+      /\.module\.(t|j)s/.test(filename),
+    );
+    return moduleFilename !== undefined
+      ? join(directory.path, moduleFilename.valueOf())
+      : this.findIn(directory.parent);
+  }
+}

package/utils/name.parser.js

@@ -5,15 +5,15 @@ const core_1 = require("@angular-devkit/core");
 class NameParser {
     constructor() { }
     parse(options) {
-        const nameWithoutPath = core_1.basename(options.name);
-        const namePath = core_1.dirname((options.path === undefined
+        const nameWithoutPath = (0, core_1.basename)(options.name);
+        const namePath = (0, core_1.dirname)((options.path === undefined
             ? ''
             : options.path)
             .concat('/')
             .concat(options.name));
         return {
             name: nameWithoutPath,
-            path: core_1.normalize('/'.concat(namePath)),
+            path: (0, core_1.normalize)('/'.concat(namePath)),
         };
     }
 }

package/utils/name.parser.ts

@@ -0,0 +1,29 @@
+import { basename, dirname, normalize, Path } from '@angular-devkit/core';
+
+export interface ParseOptions {
+  name: string;
+  path?: string;
+}
+
+export interface Location {
+  name: string;
+  path: Path;
+}
+
+export class NameParser {
+  constructor() {}
+
+  public parse(options: ParseOptions): Location {
+    const nameWithoutPath: string = basename(options.name as Path);
+    const namePath: string = dirname((options.path === undefined
+      ? ''
+      : options.path
+    )
+      .concat('/')
+      .concat(options.name) as Path);
+    return {
+      name: nameWithoutPath,
+      path: normalize('/'.concat(namePath)),
+    };
+  }
+}

package/utils/path.solver.js

@@ -6,10 +6,10 @@ class PathSolver {
     constructor() { }
     relative(from, to) {
         const placeholder = '/placeholder';
-        const relativeDir = core_1.relative(core_1.dirname((placeholder + from)), core_1.dirname((placeholder + to)));
+        const relativeDir = (0, core_1.relative)((0, core_1.dirname)((placeholder + from)), (0, core_1.dirname)((placeholder + to)));
         return (relativeDir.startsWith('.')
             ? relativeDir
-            : './' + relativeDir).concat(relativeDir.length === 0 ? core_1.basename(to) : '/' + core_1.basename(to));
+            : './' + relativeDir).concat(relativeDir.length === 0 ? (0, core_1.basename)(to) : '/' + (0, core_1.basename)(to));
     }
 }
 exports.PathSolver = PathSolver;

package/utils/path.solver.ts

@@ -0,0 +1,17 @@
+import { basename, dirname, Path, relative } from '@angular-devkit/core';
+
+export class PathSolver {
+  constructor() {}
+
+  public relative(from: Path, to: Path): string {
+    const placeholder = '/placeholder';
+    const relativeDir = relative(
+      dirname((placeholder + from) as Path),
+      dirname((placeholder + to) as Path),
+    );
+    return (relativeDir.startsWith('.')
+      ? relativeDir
+      : './' + relativeDir
+    ).concat(relativeDir.length === 0 ? basename(to) : '/' + basename(to));
+  }
+}

package/utils/source-root.helpers.js

@@ -17,8 +17,8 @@ function mergeSourceRoot(options) {
         const defaultSourceRoot = options.sourceRoot !== undefined ? options.sourceRoot : defaults_1.DEFAULT_PATH_NAME;
         options.path =
             options.path !== undefined
-                ? core_1.join(core_1.normalize(defaultSourceRoot), options.path)
-                : core_1.normalize(defaultSourceRoot);
+                ? (0, core_1.join)((0, core_1.normalize)(defaultSourceRoot), options.path)
+                : (0, core_1.normalize)(defaultSourceRoot);
         return host;
     };
 }

package/utils/source-root.helpers.ts

@@ -0,0 +1,30 @@
+import { join, normalize } from '@angular-devkit/core';
+import { Rule, Tree } from '@angular-devkit/schematics';
+import { DEFAULT_PATH_NAME } from '../lib/defaults';
+
+export function isInRootDirectory(
+  host: Tree,
+  extraFiles: string[] = [],
+): boolean {
+  const files = ['nest-cli.json', 'nest.json'].concat(extraFiles || []);
+  return files.map(file => host.exists(file)).some(isPresent => isPresent);
+}
+
+export function mergeSourceRoot<
+  T extends { sourceRoot?: string; path?: string } = any
+>(options: T): Rule {
+  return (host: Tree) => {
+    const isInRoot = isInRootDirectory(host, ['tsconfig.json', 'package.json']);
+    if (!isInRoot) {
+      return host;
+    }
+    const defaultSourceRoot =
+      options.sourceRoot !== undefined ? options.sourceRoot : DEFAULT_PATH_NAME;
+
+    options.path =
+      options.path !== undefined
+        ? join(normalize(defaultSourceRoot), options.path)
+        : normalize(defaultSourceRoot);
+    return host;
+  };
+}