@nestjs/schematics 11.0.9 → 12.0.0-alpha.0

package/dist/{lib → src/lib}/client-app/angular/angular.factory.js

@@ -1,57 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = main;
-const core_1 = require("@angular-devkit/core");
-const schematics_1 = require("@angular-devkit/schematics");
-const path_1 = require("path");
-const module_declarator_1 = require("../../../utils/module.declarator");
-const module_finder_1 = require("../../../utils/module.finder");
-const name_parser_1 = require("../../../utils/name.parser");
-const source_root_helpers_1 = require("../../../utils/source-root.helpers");
-function main(options) {
+import { strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, externalSchematic, mergeWith, move, noop, template, url, } from '@angular-devkit/schematics';
+import { join } from 'path';
+import { ModuleDeclarator, } from '../../../utils/module.declarator.js';
+import { ModuleFinder } from '../../../utils/module.finder.js';
+import { NameParser } from '../../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../../utils/source-root.helpers.js';
+export function main(options) {
     options = transform(options);
     return (tree, context) => {
-        return (0, schematics_1.branchAndMerge)((0, schematics_1.chain)([
+        return branchAndMerge(chain([
             createAngularApplication(options),
-            (0, source_root_helpers_1.mergeSourceRoot)(options),
+            mergeSourceRoot(options),
             addDeclarationToModule(options),
             addGlobalPrefix(),
-            (0, schematics_1.mergeWith)(generate(options)),
+            mergeWith(generate(options)),
         ]))(tree, context);
     };
 }
 function transform(source) {
     const target = Object.assign({}, source);
-    target.directory = target.name ? core_1.strings.dasherize(target.name) : 'client';
+    target.directory = target.name ? strings.dasherize(target.name) : 'client';
     target.name = 'Angular';
     target.metadata = 'imports';
     target.type = 'module';
-    const location = new name_parser_1.NameParser().parse(target);
-    target.name = core_1.strings.dasherize(location.name);
-    target.path = (0, path_1.join)(core_1.strings.dasherize(location.path), target.name);
+    const location = new NameParser().parse(target);
+    target.name = strings.dasherize(location.name);
+    target.path = join(strings.dasherize(location.path), target.name);
     return target;
 }
 function generate(options) {
-    return (context) => (0, schematics_1.apply)((0, schematics_1.url)('./files'), [
-        (0, schematics_1.template)({
-            ...core_1.strings,
+    return (context) => apply(url('./files'), [
+        template({
+            ...strings,
             ...options,
         }),
-        (0, schematics_1.move)(options.path),
+        move(options.path),
     ])(context);
 }
 function createAngularApplication(options) {
     if (!options.initApp) {
-        return (0, schematics_1.noop)();
+        return noop();
     }
-    return (0, schematics_1.externalSchematic)('@schematics/angular', 'ng-new', {
+    return externalSchematic('@schematics/angular', 'ng-new', {
         name: options.directory,
         version: '8.0.0',
     });
 }
 function addDeclarationToModule(options) {
     return (tree) => {
-        options.module = new module_finder_1.ModuleFinder(tree).find({
+        options.module = new ModuleFinder(tree).find({
             name: options.name,
             path: options.path,
         });
@@ -59,7 +56,7 @@ function addDeclarationToModule(options) {
             return tree;
         }
         const content = tree.read(options.module).toString();
-        const declarator = new module_declarator_1.ModuleDeclarator();
+        const declarator = new ModuleDeclarator();
         const rootPath = `${options.directory}/dist/${options.directory}`;
         const staticOptions = {
             name: 'forRoot',

package/dist/{lib → src/lib}/configuration/configuration.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { ConfigurationOptions } from './configuration.schema';
+import type { ConfigurationOptions } from './configuration.schema.js';
 export declare function main(options: ConfigurationOptions): Rule;

package/dist/src/lib/configuration/configuration.factory.js

@@ -0,0 +1,24 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, mergeWith, move, template, url, } from '@angular-devkit/schematics';
+import { DEFAULT_LANGUAGE } from '../defaults.js';
+export function main(options) {
+    return mergeWith(generate(transform(options)));
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    target.language =
+        target.language !== undefined ? target.language : DEFAULT_LANGUAGE;
+    target.collection =
+        target.collection !== undefined ? target.collection : '@nestjs/schematics';
+    return target;
+}
+function generate(options) {
+    const projectOrPath = options.project ?? '.';
+    return apply(url(join('./files', options.language)), [
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(projectOrPath),
+    ]);
+}

package/dist/{lib → src/lib}/controller/controller.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { ControllerOptions } from './controller.schema';
+import type { ControllerOptions } from './controller.schema.js';
 export declare function main(options: ControllerOptions): Rule;

package/dist/src/lib/controller/controller.factory.js

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

package/dist/{lib → src/lib}/decorator/decorator.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { DecoratorOptions } from './decorator.schema';
+import type { DecoratorOptions } from './decorator.schema.js';
 export declare function main(options: DecoratorOptions): Rule;

package/dist/src/lib/decorator/decorator.factory.js

@@ -0,0 +1,32 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, mergeWith, move, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+export function main(options) {
+    options = transform(options);
+    return chain([mergeSourceRoot(options), mergeWith(generate(options))]);
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url(join('./files', options.language)), [
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}

package/dist/src/lib/defaults.js

@@ -0,0 +1,14 @@
+export const DEFAULT_AUTHOR = '';
+export const DEFAULT_DESCRIPTION = '';
+export const DEFAULT_LANGUAGE = 'ts';
+export const DEFAULT_VERSION = '0.0.1';
+export const DEFAULT_PATH_NAME = 'src';
+export const DEFAULT_LIB_PATH = 'libs';
+export const DEFAULT_APPS_PATH = 'apps';
+export const DEFAULT_APP_NAME = 'app';
+export const DEFAULT_DIR_ENTRY_APP = 'main';
+export const TEST_ENV = 'test';
+export const PROJECT_TYPE = {
+    LIBRARY: 'library',
+    APPLICATION: 'application',
+};

package/dist/{lib → src/lib}/filter/filter.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { FilterOptions } from './filter.schema';
+import type { FilterOptions } from './filter.schema.js';
 export declare function main(options: FilterOptions): Rule;

package/dist/src/lib/filter/filter.factory.js

@@ -0,0 +1,40 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+export function main(options) {
+    options = transform(options);
+    return chain([mergeSourceRoot(options), mergeWith(generate(options))]);
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    target.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url(join('./files', options.language)), [
+        options.spec
+            ? noop()
+            : filter((path) => {
+                const languageExtension = options.language || 'ts';
+                const suffix = `.__specFileSuffix__.${languageExtension}`;
+                return !path.endsWith(suffix);
+            }),
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}

package/dist/{lib → src/lib}/gateway/gateway.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { GatewayOptions } from './gateway.schema';
+import type { GatewayOptions } from './gateway.schema.js';
 export declare function main(options: GatewayOptions): Rule;

package/dist/src/lib/gateway/gateway.factory.js

@@ -0,0 +1,69 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { ModuleDeclarator, } from '../../utils/module.declarator.js';
+import { ModuleFinder } from '../../utils/module.finder.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+export function main(options) {
+    options = transform(options);
+    return (tree, context) => {
+        return branchAndMerge(chain([
+            mergeSourceRoot(options),
+            addDeclarationToModule(options),
+            mergeWith(generate(options)),
+        ]))(tree, context);
+    };
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    target.metadata = 'providers';
+    target.type = 'gateway';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url(join('./files', options.language)), [
+        options.spec ? noop() : filter((path) => !path.endsWith('.spec.ts')),
+        options.spec
+            ? noop()
+            : filter((path) => {
+                const languageExtension = options.language || 'ts';
+                const suffix = `.__specFileSuffix__.${languageExtension}`;
+                return !path.endsWith(suffix);
+            }),
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}
+function addDeclarationToModule(options) {
+    return (tree) => {
+        if (options.skipImport !== undefined && options.skipImport) {
+            return tree;
+        }
+        options.module = new ModuleFinder(tree).find({
+            name: options.name,
+            path: options.path,
+        });
+        if (!options.module) {
+            return tree;
+        }
+        const content = tree.read(options.module).toString();
+        const declarator = new ModuleDeclarator();
+        tree.overwrite(options.module, declarator.declare(content, options));
+        return tree;
+    };
+}

package/dist/{lib → src/lib}/guard/guard.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { GuardOptions } from './guard.schema';
+import type { GuardOptions } from './guard.schema.js';
 export declare function main(options: GuardOptions): Rule;

package/dist/src/lib/guard/guard.factory.js

@@ -0,0 +1,40 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+export function main(options) {
+    options = transform(options);
+    return chain([mergeSourceRoot(options), mergeWith(generate(options))]);
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    target.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url(join('./files', options.language)), [
+        options.spec
+            ? noop()
+            : filter((path) => {
+                const languageExtension = options.language || 'ts';
+                const suffix = `.__specFileSuffix__.${languageExtension}`;
+                return !path.endsWith(suffix);
+            }),
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}

package/dist/{lib → src/lib}/interceptor/interceptor.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { InterceptorOptions } from './interceptor.schema';
+import type { InterceptorOptions } from './interceptor.schema.js';
 export declare function main(options: InterceptorOptions): Rule;

package/dist/src/lib/interceptor/interceptor.factory.js

@@ -0,0 +1,41 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+export function main(options) {
+    options = transform(options);
+    return chain([mergeSourceRoot(options), mergeWith(generate(options))]);
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    target.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url(join('./files', options.language)), [
+        options.spec ? noop() : filter((path) => !path.endsWith('.spec.ts')),
+        options.spec
+            ? noop()
+            : filter((path) => {
+                const languageExtension = options.language || 'ts';
+                const suffix = `.__specFileSuffix__.${languageExtension}`;
+                return !path.endsWith(suffix);
+            }),
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}

package/dist/{lib → src/lib}/interface/interface.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { InterfaceOptions } from './interface.schema';
+import type { InterfaceOptions } from './interface.schema.js';
 export declare function main(options: InterfaceOptions): Rule;

package/dist/src/lib/interface/interface.factory.js

@@ -0,0 +1,31 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, mergeWith, move, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+export function main(options) {
+    options = transform(options);
+    return chain([mergeSourceRoot(options), mergeWith(generate(options))]);
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url('./files'), [
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}

package/dist/{lib → src/lib}/library/library.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { LibraryOptions } from './library.schema';
+import type { LibraryOptions } from './library.schema.js';
 export declare function main(options: LibraryOptions): Rule;