@nestjs/schematics 11.0.9 → 12.0.0-alpha.0

package/dist/{utils → src/utils}/json-file.util.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONFile = void 0;
-const jsonc_parser_1 = require("jsonc-parser");
-class JSONFile {
+import { applyEdits, findNodeAtLocation, getNodeValue, modify, parseTree, printParseErrorCode, } from 'jsonc-parser';
+export class JSONFile {
     host;
     path;
     content;
@@ -23,12 +20,12 @@ class JSONFile {
             return this._jsonAst;
         }
         const errors = [];
-        this._jsonAst = (0, jsonc_parser_1.parseTree)(this.content, errors, {
+        this._jsonAst = parseTree(this.content, errors, {
             allowTrailingComma: true,
         });
         if (errors.length) {
             const { error, offset } = errors[0];
-            throw new Error(`Failed to parse "${this.path}" as JSON AST Object. ${(0, jsonc_parser_1.printParseErrorCode)(error)} at location: ${offset}.`);
+            throw new Error(`Failed to parse "${this.path}" as JSON AST Object. ${printParseErrorCode(error)} at location: ${offset}.`);
         }
         return this._jsonAst;
     }
@@ -38,10 +35,10 @@ class JSONFile {
             return undefined;
         }
         if (jsonPath.length === 0) {
-            return (0, jsonc_parser_1.getNodeValue)(jsonAstNode);
+            return getNodeValue(jsonAstNode);
         }
-        const node = (0, jsonc_parser_1.findNodeAtLocation)(jsonAstNode, jsonPath);
-        return node === undefined ? undefined : (0, jsonc_parser_1.getNodeValue)(node);
+        const node = findNodeAtLocation(jsonAstNode, jsonPath);
+        return node === undefined ? undefined : getNodeValue(node);
     }
     modify(jsonPath, value, insertInOrder) {
         let getInsertionIndex;
@@ -52,14 +49,14 @@ class JSONFile {
         else if (insertInOrder !== false) {
             getInsertionIndex = insertInOrder;
         }
-        const edits = (0, jsonc_parser_1.modify)(this.content, jsonPath, value, {
+        const edits = modify(this.content, jsonPath, value, {
             getInsertionIndex,
             formattingOptions: {
                 insertSpaces: true,
                 tabSize: 2,
             },
         });
-        this.content = (0, jsonc_parser_1.applyEdits)(this.content, edits);
+        this.content = applyEdits(this.content, edits);
         this.host.overwrite(this.path, this.content);
         this._jsonAst = undefined;
     }
@@ -69,4 +66,3 @@ class JSONFile {
         }
     }
 }
-exports.JSONFile = JSONFile;

package/dist/{utils → src/utils}/metadata.manager.d.ts

@@ -1,4 +1,4 @@
-import { DeclarationOptions } from './module.declarator';
+import { DeclarationOptions } from './module.declarator.js';
 export declare class MetadataManager {
     private content;
     constructor(content: string);

package/dist/{utils → src/utils}/metadata.manager.js

@@ -1,26 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataManager = void 0;
-const typescript_1 = require("typescript");
-class MetadataManager {
+import { createSourceFile, ScriptTarget, SyntaxKind, } from 'typescript';
+export class MetadataManager {
     content;
     constructor(content) {
         this.content = content;
     }
     insert(metadata, symbol, staticOptions) {
-        const source = (0, typescript_1.createSourceFile)('filename.ts', this.content, typescript_1.ScriptTarget.ES2017);
+        const source = createSourceFile('filename.ts', this.content, ScriptTarget.ES2017);
         const moduleDecoratorNode = this.findFirstDecoratorMetadata(source, 'Module');
         if (!moduleDecoratorNode) {
             return;
         }
         const matchingProperties = moduleDecoratorNode.properties
-            .filter((prop) => prop.kind === typescript_1.SyntaxKind.PropertyAssignment)
+            .filter((prop) => prop.kind === SyntaxKind.PropertyAssignment)
             .filter((prop) => {
             const name = prop.name;
             switch (name.kind) {
-                case typescript_1.SyntaxKind.Identifier:
+                case SyntaxKind.Identifier:
                     return name.getText(source) === metadata;
-                case typescript_1.SyntaxKind.StringLiteral:
+                case SyntaxKind.StringLiteral:
                     return name.text === metadata;
                 default:
                     return false;
@@ -47,15 +44,15 @@ class MetadataManager {
     }
     findFirstDecoratorMetadata(source, identifier) {
         for (const node of this.getSourceNodes(source)) {
-            const isDecoratorFactoryNode = node.kind === typescript_1.SyntaxKind.Decorator &&
-                node.expression.kind === typescript_1.SyntaxKind.CallExpression;
+            const isDecoratorFactoryNode = node.kind === SyntaxKind.Decorator &&
+                node.expression.kind === SyntaxKind.CallExpression;
             if (!isDecoratorFactoryNode)
                 continue;
             const expr = node.expression;
-            const isExpectedExpression = expr.arguments[0]?.kind === typescript_1.SyntaxKind.ObjectLiteralExpression;
+            const isExpectedExpression = expr.arguments[0]?.kind === SyntaxKind.ObjectLiteralExpression;
             if (!isExpectedExpression)
                 continue;
-            if (expr.expression.kind === typescript_1.SyntaxKind.Identifier) {
+            if (expr.expression.kind === SyntaxKind.Identifier) {
                 const escapedText = expr.expression.escapedText;
                 const isTargetIdentifier = escapedText
                     ? escapedText.toLowerCase() === identifier.toLowerCase()
@@ -136,7 +133,7 @@ class MetadataManager {
         }
         let toInsert;
         let position = node.getEnd();
-        if (node.kind === typescript_1.SyntaxKind.ArrayLiteralExpression) {
+        if (node.kind === SyntaxKind.ArrayLiteralExpression) {
             position--;
             toInsert = staticOptions ? this.addBlankLines(symbol) : `${symbol}`;
         }
@@ -172,4 +169,3 @@ class MetadataManager {
         return `\n    ${expr}\n  `;
     }
 }
-exports.MetadataManager = MetadataManager;

package/dist/{utils → src/utils}/module-import.declarator.d.ts

@@ -1,5 +1,5 @@
-import { DeclarationOptions } from './module.declarator';
-import { PathSolver } from './path.solver';
+import { DeclarationOptions } from './module.declarator.js';
+import { PathSolver } from './path.solver.js';
 export declare class ModuleImportDeclarator {
     private solver;
     constructor(solver?: PathSolver);

package/dist/{utils → src/utils}/module-import.declarator.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleImportDeclarator = void 0;
-const core_1 = require("@angular-devkit/core");
-const path_solver_1 = require("./path.solver");
-class ModuleImportDeclarator {
+import { normalize } from '@angular-devkit/core';
+import { PathSolver } from './path.solver.js';
+export class ModuleImportDeclarator {
     solver;
-    constructor(solver = new path_solver_1.PathSolver()) {
+    constructor(solver = new PathSolver()) {
         this.solver = solver;
     }
     declare(content, options) {
@@ -29,12 +26,11 @@ class ModuleImportDeclarator {
     computeRelativePath(options) {
         let importModulePath;
         if (options.type !== undefined) {
-            importModulePath = (0, core_1.normalize)(`/${options.path}/${options.name}.${options.type}`);
+            importModulePath = normalize(`/${options.path}/${options.name}.${options.type}`);
         }
         else {
-            importModulePath = (0, core_1.normalize)(`/${options.path}/${options.name}`);
+            importModulePath = normalize(`/${options.path}/${options.name}`);
         }
         return this.solver.relative(options.module, importModulePath);
     }
 }
-exports.ModuleImportDeclarator = ModuleImportDeclarator;

package/dist/{utils → src/utils}/module-metadata.declarator.d.ts

@@ -1,4 +1,4 @@
-import { DeclarationOptions } from './module.declarator';
+import { DeclarationOptions } from './module.declarator.js';
 export declare class ModuleMetadataDeclarator {
     declare(content: string, options: DeclarationOptions): string;
 }

package/dist/src/utils/module-metadata.declarator.js

@@ -0,0 +1,8 @@
+import { MetadataManager } from './metadata.manager.js';
+export class ModuleMetadataDeclarator {
+    declare(content, options) {
+        const manager = new MetadataManager(content);
+        const inserted = manager.insert(options.metadata, options.symbol, options.staticOptions);
+        return inserted ?? content;
+    }
+}

package/dist/{utils → src/utils}/module.declarator.d.ts

@@ -1,6 +1,6 @@
 import { Path } from '@angular-devkit/core';
-import { ModuleImportDeclarator } from './module-import.declarator';
-import { ModuleMetadataDeclarator } from './module-metadata.declarator';
+import { ModuleImportDeclarator } from './module-import.declarator.js';
+import { ModuleMetadataDeclarator } from './module-metadata.declarator.js';
 export interface DeclarationOptions {
     metadata: string;
     type?: string;

package/dist/src/utils/module.declarator.js

@@ -0,0 +1,30 @@
+import { capitalize, classify } from '@angular-devkit/core/src/utils/strings';
+import { ModuleImportDeclarator } from './module-import.declarator.js';
+import { ModuleMetadataDeclarator } from './module-metadata.declarator.js';
+export class ModuleDeclarator {
+    imports;
+    metadata;
+    constructor(imports = new ModuleImportDeclarator(), metadata = new ModuleMetadataDeclarator()) {
+        this.imports = imports;
+        this.metadata = metadata;
+    }
+    declare(content, options) {
+        options = this.computeSymbol(options);
+        content = this.imports.declare(content, options);
+        content = this.metadata.declare(content, options);
+        return content;
+    }
+    computeSymbol(options) {
+        const target = Object.assign({}, options);
+        if (options.className) {
+            target.symbol = options.className;
+        }
+        else if (options.type !== undefined) {
+            target.symbol = classify(options.name).concat(capitalize(options.type));
+        }
+        else {
+            target.symbol = classify(options.name);
+        }
+        return target;
+    }
+}

package/dist/{utils → src/utils}/module.finder.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleFinder = void 0;
-const core_1 = require("@angular-devkit/core");
-class ModuleFinder {
+import { join } from '@angular-devkit/core';
+export class ModuleFinder {
     tree;
     constructor(tree) {
         this.tree = tree;
@@ -18,8 +15,7 @@ class ModuleFinder {
         }
         const moduleFilename = directory.subfiles.find((filename) => /\.module\.(t|j)s$/.test(filename));
         return moduleFilename !== undefined
-            ? (0, core_1.join)(directory.path, moduleFilename.valueOf())
+            ? join(directory.path, moduleFilename.valueOf())
             : this.findIn(directory.parent);
     }
 }
-exports.ModuleFinder = ModuleFinder;

package/dist/src/utils/name.parser.js

@@ -0,0 +1,13 @@
+import { basename, dirname, normalize } from '@angular-devkit/core';
+export class NameParser {
+    parse(options) {
+        const nameWithoutPath = basename(options.name);
+        const namePath = dirname((options.path === undefined ? '' : options.path)
+            .concat('/')
+            .concat(options.name));
+        return {
+            name: nameWithoutPath,
+            path: normalize('/'.concat(namePath)),
+        };
+    }
+}

package/dist/{utils → src/utils}/object-sorting.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inPlaceSortByKeys = inPlaceSortByKeys;
-function inPlaceSortByKeys(object) {
+export function inPlaceSortByKeys(object) {
     const sorted = {};
     const keys = Object.keys(object);
     keys.sort();

package/dist/src/utils/path.solver.js

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

package/dist/src/utils/source-root.helpers.js

@@ -0,0 +1,20 @@
+import { join, normalize } from '@angular-devkit/core';
+import { DEFAULT_PATH_NAME } from '../lib/defaults.js';
+export function isInRootDirectory(host, extraFiles = []) {
+    const files = ['nest-cli.json', 'nest.json'].concat(extraFiles || []);
+    return files.map((file) => host.exists(file)).some((isPresent) => isPresent);
+}
+export function mergeSourceRoot(options) {
+    return (host) => {
+        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;
+    };
+}