@gadmin2n/schematics 0.0.55

package/dist/lib/library/library.factory.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const jsonc_parser_1 = require("jsonc-parser");
+const formatting_1 = require("../../utils/formatting");
+const defaults_1 = require("../defaults");
+function main(options) {
+    options = transform(options);
+    return (0, schematics_1.chain)([
+        addLibraryToCliOptions(options.path, options.name),
+        updatePackageJson(options),
+        updateJestEndToEnd(options),
+        updateTsConfig(options.name, options.prefix, options.path),
+        (0, schematics_1.branchAndMerge)((0, schematics_1.mergeWith)(generate(options))),
+    ]);
+}
+exports.main = main;
+function transform(options) {
+    const target = Object.assign({}, options);
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_LIB_PATH;
+    if (!target.name) {
+        throw new schematics_1.SchematicsException('Option (name) is required.');
+    }
+    target.language = !!target.language ? target.language : defaults_1.DEFAULT_LANGUAGE;
+    target.name = (0, formatting_1.normalizeToKebabOrSnakeCase)(target.name);
+    target.path =
+        target.path !== undefined
+            ? (0, core_1.join)((0, core_1.normalize)(defaultSourceRoot), target.path)
+            : (0, core_1.normalize)(defaultSourceRoot);
+    target.prefix = target.prefix || '@app';
+    return target;
+}
+function updatePackageJson(options) {
+    return (host) => {
+        if (!host.exists('package.json')) {
+            return host;
+        }
+        const distRoot = (0, core_1.join)(options.path, options.name, 'src');
+        const packageKey = options.prefix
+            ? options.prefix + '/' + options.name
+            : options.name;
+        return updateJsonFile(host, 'package.json', (packageJson) => {
+            updateNpmScripts(packageJson.scripts, options);
+            updateJestConfig(packageJson.jest, options, packageKey, distRoot);
+        });
+    };
+}
+function updateJestConfig(jestOptions, options, packageKey, distRoot) {
+    if (!jestOptions) {
+        return;
+    }
+    if (jestOptions.rootDir === defaults_1.DEFAULT_PATH_NAME) {
+        jestOptions.rootDir = '.';
+        jestOptions.coverageDirectory = './coverage';
+    }
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_LIB_PATH;
+    const jestSourceRoot = `<rootDir>/${defaultSourceRoot}/`;
+    if (!jestOptions.roots) {
+        jestOptions.roots = ['<rootDir>/src/', jestSourceRoot];
+    }
+    else if (jestOptions.roots.indexOf(jestSourceRoot) < 0) {
+        jestOptions.roots.push(jestSourceRoot);
+    }
+    if (!jestOptions.moduleNameMapper) {
+        jestOptions.moduleNameMapper = {};
+    }
+    const packageKeyRegex = '^' + packageKey + '(|/.*)$';
+    const packageRoot = (0, core_1.join)('<rootDir>', distRoot);
+    jestOptions.moduleNameMapper[packageKeyRegex] = (0, core_1.join)(packageRoot, '$1');
+}
+function updateNpmScripts(scripts, options) {
+    if (!scripts) {
+        return;
+    }
+    const defaultFormatScriptName = 'format';
+    if (!scripts[defaultFormatScriptName]) {
+        return;
+    }
+    if (scripts[defaultFormatScriptName] &&
+        scripts[defaultFormatScriptName].indexOf(defaults_1.DEFAULT_PATH_NAME) >= 0) {
+        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_LIB_PATH;
+        scripts[defaultFormatScriptName] = `prettier --write "src/**/*.ts" "test/**/*.ts" "${defaultSourceRoot}/**/*.ts"`;
+    }
+}
+function updateJestEndToEnd(options) {
+    return (host) => {
+        const pathToFile = (0, core_1.join)('test', 'jest-e2e.json');
+        if (!host.exists(pathToFile)) {
+            return host;
+        }
+        const distRoot = (0, core_1.join)(options.path, options.name, 'src');
+        const packageKey = options.prefix
+            ? options.prefix + '/' + options.name
+            : options.name;
+        return updateJsonFile(host, pathToFile, (jestOptions) => {
+            if (!jestOptions.moduleNameMapper) {
+                jestOptions.moduleNameMapper = {};
+            }
+            const deepPackagePath = packageKey + '/(.*)';
+            const packageRoot = '<rootDir>/../' + distRoot;
+            jestOptions.moduleNameMapper[deepPackagePath] = packageRoot + '/$1';
+            jestOptions.moduleNameMapper[packageKey] = packageRoot;
+        });
+    };
+}
+function updateJsonFile(host, path, callback) {
+    const source = host.read(path);
+    if (source) {
+        const sourceText = source.toString('utf-8');
+        const json = (0, jsonc_parser_1.parse)(sourceText);
+        callback(json);
+        host.overwrite(path, JSON.stringify(json, null, 2));
+    }
+    return host;
+}
+function updateTsConfig(packageName, packagePrefix, root) {
+    return (host) => {
+        if (!host.exists('tsconfig.json')) {
+            return host;
+        }
+        const distRoot = (0, core_1.join)(root, packageName, 'src');
+        const packageKey = packagePrefix
+            ? packagePrefix + '/' + packageName
+            : packageName;
+        return updateJsonFile(host, 'tsconfig.json', (tsconfig) => {
+            if (!tsconfig.compilerOptions) {
+                tsconfig.compilerOptions = {};
+            }
+            if (!tsconfig.compilerOptions.baseUrl) {
+                tsconfig.compilerOptions.baseUrl = './';
+            }
+            if (!tsconfig.compilerOptions.paths) {
+                tsconfig.compilerOptions.paths = {};
+            }
+            if (!tsconfig.compilerOptions.paths[packageKey]) {
+                tsconfig.compilerOptions.paths[packageKey] = [];
+            }
+            tsconfig.compilerOptions.paths[packageKey].push(distRoot);
+            const deepPackagePath = packageKey + '/*';
+            if (!tsconfig.compilerOptions.paths[deepPackagePath]) {
+                tsconfig.compilerOptions.paths[deepPackagePath] = [];
+            }
+            tsconfig.compilerOptions.paths[deepPackagePath].push(distRoot + '/*');
+        });
+    };
+}
+function addLibraryToCliOptions(projectRoot, projectName) {
+    const rootPath = (0, core_1.join)(projectRoot, projectName);
+    const project = {
+        type: defaults_1.PROJECT_TYPE.LIBRARY,
+        root: rootPath,
+        entryFile: 'index',
+        sourceRoot: (0, core_1.join)(rootPath, 'src'),
+        compilerOptions: {
+            tsConfigPath: (0, core_1.join)(rootPath, 'tsconfig.lib.json'),
+        },
+    };
+    return (host) => {
+        const nestFileExists = host.exists('nest.json');
+        let nestCliFileExists = host.exists('nest-cli.json');
+        if (!nestCliFileExists && !nestFileExists) {
+            host.create('nest-cli.json', '{}');
+            nestCliFileExists = true;
+        }
+        return updateJsonFile(host, nestCliFileExists ? 'nest-cli.json' : 'nest.json', (optionsFile) => {
+            if (!optionsFile.projects) {
+                optionsFile.projects = {};
+            }
+            if (!optionsFile.compilerOptions) {
+                optionsFile.compilerOptions = {};
+            }
+            if (optionsFile.compilerOptions.webpack === undefined) {
+                optionsFile.compilerOptions.webpack = true;
+            }
+            if (optionsFile.projects[projectName]) {
+                throw new schematics_1.SchematicsException(`Project "${projectName}" exists in this workspace already.`);
+            }
+            optionsFile.projects[projectName] = project;
+        });
+    };
+}
+function generate(options) {
+    const path = (0, core_1.join)(options.path, options.name);
+    return (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
+        (0, schematics_1.template)(Object.assign(Object.assign({}, core_1.strings), options)),
+        (0, schematics_1.move)(path),
+    ]);
+}

package/dist/lib/library/schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "SchematicsNestLibrary",
+  "title": "Nest Library Options Schema",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the library.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the library?"
+    },
+    "prefix": {
+      "type": "string",
+      "description": "The prefix of the library.",
+      "x-prompt": "What prefix would you like to use for the library (default: @app)?"
+    },
+    "language": {
+      "type": "string",
+      "description": "Nest library language."
+    },
+    "path": {
+      "type": "string",
+      "format": "path",
+      "description": "The path to create the library."
+    },
+    "rootDir": {
+      "type": "string",
+      "format": "path",
+      "description": "The libraries root directory."
+    }
+  },
+  "required": ["name", "prefix"]
+}

package/dist/lib/middleware/files/js/__name__.middleware.js

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class <%= classify(name) %>Middleware {
+  use(req, res, next) {
+    next();
+  }
+}

package/dist/lib/middleware/files/js/__name__.middleware.spec.js

@@ -0,0 +1,7 @@
+import { <%= classify(name) %>Middleware } from './<%= name %>.middleware';
+
+describe('<%= classify(name) %>Middleware', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(name) %>Middleware()).toBeDefined();
+  });
+});

package/dist/lib/middleware/files/ts/__name__.middleware.spec.ts

@@ -0,0 +1,7 @@
+import { <%= classify(name) %>Middleware } from './<%= name %>.middleware';
+
+describe('<%= classify(name) %>Middleware', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(name) %>Middleware()).toBeDefined();
+  });
+});

package/dist/lib/middleware/files/ts/__name__.middleware.ts

@@ -0,0 +1,8 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+
+@Injectable()
+export class <%= classify(name) %>Middleware implements NestMiddleware {
+  use(req: any, res: any, next: () => void) {
+    next();
+  }
+}

package/dist/lib/middleware/middleware.factory.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { MiddlewareOptions } from './middleware.schema';
+export declare function main(options: MiddlewareOptions): Rule;

package/dist/lib/middleware/middleware.factory.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const formatting_1 = require("../../utils/formatting");
+const name_parser_1 = require("../../utils/name.parser");
+const source_root_helpers_1 = require("../../utils/source-root.helpers");
+function main(options) {
+    options = transform(options);
+    return (0, schematics_1.chain)([(0, source_root_helpers_1.mergeSourceRoot)(options), (0, schematics_1.mergeWith)(generate(options))]);
+}
+exports.main = main;
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new schematics_1.SchematicsException('Option (name) is required.');
+    }
+    const location = new name_parser_1.NameParser().parse(target);
+    target.name = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.name);
+    target.path = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.path = target.flat
+        ? target.path
+        : (0, core_1.join)(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
+        options.spec ? (0, schematics_1.noop)() : (0, schematics_1.filter)((path) => !path.endsWith('.spec.ts')),
+        (0, schematics_1.template)(Object.assign(Object.assign({}, core_1.strings), options)),
+        (0, schematics_1.move)(options.path),
+    ])(context);
+}

package/dist/lib/middleware/schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "SchematicsNestMiddleware",
+  "title": "Nest Middleware Options Schema",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the middleware.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the middleware?"
+    },
+    "path": {
+      "type": "string",
+      "format": "path",
+      "description": "The path to create the middleware."
+    },
+    "language": {
+      "type": "string",
+      "description": "Nest middleware language (ts/js)."
+    },
+    "sourceRoot": {
+      "type": "string",
+      "description": "Nest middleware source root directory."
+    },
+    "flat": {
+      "type": "boolean",
+      "default": true,
+      "description": "Flag to indicate if a directory is created."
+    },
+    "spec": {
+      "type": "boolean",
+      "default": true,
+      "description": "Specifies if a spec file is generated."
+    }
+  },
+  "required": ["name"]
+}

package/dist/lib/module/files/js/__name__.module.js

@@ -0,0 +1,4 @@
+import { Module } from '@nestjs/common';
+
+@Module({})
+export class <%= classify(name) %>Module {}

package/dist/lib/module/files/ts/__name__.module.ts

@@ -0,0 +1,4 @@
+import { Module } from '@nestjs/common';
+
+@Module({})
+export class <%= classify(name) %>Module {}

package/dist/lib/module/module.factory.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { ModuleOptions } from './module.schema';
+export declare function main(options: ModuleOptions): Rule;

package/dist/lib/module/module.factory.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const formatting_1 = require("../../utils/formatting");
+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) {
+    options = transform(options);
+    return (tree, context) => {
+        return (0, schematics_1.branchAndMerge)((0, schematics_1.chain)([
+            (0, source_root_helpers_1.mergeSourceRoot)(options),
+            addDeclarationToModule(options),
+            (0, schematics_1.mergeWith)(generate(options)),
+        ]))(tree, context);
+    };
+}
+exports.main = main;
+function transform(source) {
+    const target = Object.assign({}, source);
+    target.metadata = 'imports';
+    target.type = 'module';
+    const location = new name_parser_1.NameParser().parse(target);
+    target.name = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.name);
+    target.path = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.path = target.flat
+        ? target.path
+        : (0, core_1.join)(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
+        (0, schematics_1.template)(Object.assign(Object.assign({}, core_1.strings), options)),
+        (0, schematics_1.move)(options.path),
+    ])(context);
+}
+function addDeclarationToModule(options) {
+    return (tree) => {
+        if (options.skipImport !== undefined && options.skipImport) {
+            return tree;
+        }
+        options.module = new module_finder_1.ModuleFinder(tree).find({
+            name: options.name,
+            path: options.path,
+        });
+        if (!options.module) {
+            return tree;
+        }
+        const content = tree.read(options.module).toString();
+        const declarator = new module_declarator_1.ModuleDeclarator();
+        tree.overwrite(options.module, declarator.declare(content, options));
+        return tree;
+    };
+}

package/dist/lib/module/schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "SchematicsNestModule",
+  "title": "Nest Module Options Schema",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the module.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the module?"
+    },
+    "path": {
+      "type": "string",
+      "format": "path",
+      "description": "The path to create the module."
+    },
+    "module": {
+      "type": "string",
+      "format": "path",
+      "description": "The path to import the module."
+    },
+    "language": {
+      "type": "string",
+      "description": "Nest module language (ts/js)."
+    },
+    "sourceRoot": {
+      "type": "string",
+      "description": "Nest module source root directory."
+    },
+    "skipImport": {
+      "type": "boolean",
+      "description": "Flag to skip the module import.",
+      "default": false
+    },
+    "flat": {
+      "type": "boolean",
+      "default": false,
+      "description": "Flag to indicate if a directory is created."
+    }
+  },
+  "required": ["name"]
+}

package/dist/lib/pipe/files/js/__name__.pipe.js

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class <%= classify(name) %>Pipe {
+  transform(value, metadata) {
+    return value;
+  }
+}

package/dist/lib/pipe/files/js/__name__.pipe.spec.js

@@ -0,0 +1,7 @@
+import { <%= classify(name) %>Pipe } from './<%= name %>.pipe';
+
+describe('<%= classify(name) %>Pipe', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(name) %>Pipe()).toBeDefined();
+  });
+});

package/dist/lib/pipe/files/ts/__name__.pipe.spec.ts

@@ -0,0 +1,7 @@
+import { <%= classify(name) %>Pipe } from './<%= name %>.pipe';
+
+describe('<%= classify(name) %>Pipe', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(name) %>Pipe()).toBeDefined();
+  });
+});

package/dist/lib/pipe/files/ts/__name__.pipe.ts

@@ -0,0 +1,8 @@
+import { ArgumentMetadata, Injectable, PipeTransform } from '@nestjs/common';
+
+@Injectable()
+export class <%= classify(name) %>Pipe implements PipeTransform {
+  transform(value: any, metadata: ArgumentMetadata) {
+    return value;
+  }
+}

package/dist/lib/pipe/pipe.factory.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { PipeOptions } from './pipe.schema';
+export declare function main(options: PipeOptions): Rule;

package/dist/lib/pipe/pipe.factory.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const formatting_1 = require("../../utils/formatting");
+const name_parser_1 = require("../../utils/name.parser");
+const source_root_helpers_1 = require("../../utils/source-root.helpers");
+function main(options) {
+    options = transform(options);
+    return (0, schematics_1.chain)([(0, source_root_helpers_1.mergeSourceRoot)(options), (0, schematics_1.mergeWith)(generate(options))]);
+}
+exports.main = main;
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new schematics_1.SchematicsException('Option (name) is required.');
+    }
+    const location = new name_parser_1.NameParser().parse(target);
+    target.name = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.name);
+    target.path = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.path = target.flat
+        ? target.path
+        : (0, core_1.join)(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
+        options.spec ? (0, schematics_1.noop)() : (0, schematics_1.filter)((path) => !path.endsWith('.spec.ts')),
+        (0, schematics_1.template)(Object.assign(Object.assign({}, core_1.strings), options)),
+        (0, schematics_1.move)(options.path),
+    ])(context);
+}

package/dist/lib/pipe/schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "SchematicsNestPipe",
+  "title": "Nest Pipe Options Schema",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the pipe.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the pipe?"
+    },
+    "path": {
+      "type": "string",
+      "format": "path",
+      "description": "The path to create the pipe."
+    },
+    "language": {
+      "type": "string",
+      "description": "Nest pipe language (ts/js)."
+    },
+    "sourceRoot": {
+      "type": "string",
+      "description": "Nest pipe source root directory."
+    },
+    "flat": {
+      "type": "boolean",
+      "default": true,
+      "description": "Flag to indicate if a directory is created."
+    },
+    "spec": {
+      "type": "boolean",
+      "default": true,
+      "description": "Specifies if a spec file is generated."
+    }
+  },
+  "required": ["name"]
+}

package/dist/lib/prisma-resource/files/ts/__name__.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { <%= classify(name) %>Controller } from './<%= name %>.controller';
+import { <%= classify(name) %>Service } from './<%= name %>.service';
+
+describe('<%= classify(name) %>Controller', () => {
+  let controller: <%= classify(name) %>Controller;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [<%= classify(name) %>Controller],
+      providers: [<%= classify(name) %>Service],
+    }).compile();
+
+    controller = module.get<<%= classify(name) %>Controller>(<%= classify(name) %>Controller);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});