@tsed/cli 6.6.3 → 7.0.0-alpha.10

package/lib/esm/services/ProjectClient.js

@@ -0,0 +1,162 @@
+import { dirname, join } from "node:path";
+import { CliDockerComposeYaml, CliFs, ProjectPackageJson } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
+import { constant, inject } from "@tsed/di";
+import { ObjectLiteralExpression, Project, SyntaxKind } from "ts-morph";
+import { OutputFilePathPipe } from "../pipes/OutputFilePathPipe.js";
+export class ProjectClient extends Project {
+    constructor({ rootDir, ...options }) {
+        super({
+            fileSystem: inject(CliFs),
+            ...options
+        });
+        this.pkg = inject(ProjectPackageJson);
+        this.fs = inject(CliFs);
+        this.dockerCompose = inject(CliDockerComposeYaml);
+        this.rootDir = rootDir;
+    }
+    get srcDir() {
+        return constant("project.srcDir", "/src");
+    }
+    get serverSourceFile() {
+        return this.getSource(join(this.srcDir, this.serverName));
+    }
+    get configSourceFile() {
+        return this.getSource(join(this.srcDir, `config/config.ts`));
+    }
+    get indexSourceFile() {
+        return this.getSource(join(this.srcDir, "index.ts"));
+    }
+    get binSourceFile() {
+        return this.getSource(join(this.srcDir, "bin/index.ts"));
+    }
+    get serverName() {
+        return inject(OutputFilePathPipe).getServerName();
+    }
+    getSource(path) {
+        const resolved = join(this.rootDir, path.replace("{{srcDir}}", this.srcDir));
+        return this.getSourceFile(resolved);
+    }
+    async createSource(path, sourceFileText, options) {
+        path = join(this.rootDir, path);
+        if (path.endsWith(".ts") || path.endsWith(".mts")) {
+            const source = this.createSourceFile(path, sourceFileText, options);
+            source.organizeImports();
+            await source.save();
+            return source;
+        }
+        await this.fs.ensureDir(dirname(path));
+        await this.fs.writeFile(path, sourceFileText, { encoding: "utf-8" });
+    }
+    findClassDecorator(sourceFile, name) {
+        return sourceFile
+            .getClasses()
+            .flatMap((cls) => cls.getDecorators())
+            .find((decorator) => decorator.getName() === name);
+    }
+    addMountPath(path, specifier) {
+        if (!this.serverSourceFile) {
+            return;
+        }
+        const options = this.findConfigurationDecorationOptions();
+        if (!options) {
+            return;
+        }
+        let mount = this.getPropertyAssignment(options, {
+            name: "mount",
+            kind: SyntaxKind.ObjectLiteralExpression,
+            initializer: "{}"
+        });
+        const escape = '"' + ((path || "").startsWith("/") ? path : "/" + path) + '"';
+        const property = this.getPropertyAssignment(mount, {
+            name: escape,
+            kind: SyntaxKind.ArrayLiteralExpression,
+            initializer: "[]"
+        });
+        if (isString(specifier)) {
+            property.addElement(specifier);
+        }
+        options.formatText({
+            indentSize: 2
+        });
+    }
+    addNamespaceImport(sourceFile, moduleSpecifier, name) {
+        return sourceFile
+            .addImportDeclaration({
+            moduleSpecifier,
+            namespaceImport: name
+        })
+            .getNamespaceImport();
+    }
+    findConfiguration(kind) {
+        switch (kind) {
+            case "server":
+                return this.findConfigurationDecorationOptions();
+            case "config":
+                return this.findConfigConfiguration();
+            case "bin":
+                return this.findBinConfiguration();
+            default:
+                throw new Error(`Unknown configuration kind: ${kind}`);
+        }
+    }
+    getPropertyAssignment(input, { name, initializer, kind }) {
+        const assigment = input.getProperty(name)?.getChildAtIndex(2).asKind(kind);
+        if (!initializer) {
+            return assigment;
+        }
+        return (assigment ||
+            input
+                .addPropertyAssignment({
+                name,
+                initializer
+            })
+                .getInitializerIfKindOrThrow(kind));
+    }
+    addConfigSource(name, { content = name, moduleSpecifier }) {
+        const sourceFile = this.configSourceFile;
+        const options = this.findConfiguration("config");
+        if (!options) {
+            return;
+        }
+        const extendsConfig = this.getPropertyAssignment(options, {
+            name: "extends",
+            kind: SyntaxKind.ArrayLiteralExpression,
+            initializer: "[]"
+        });
+        const has = extendsConfig.getElements().some((expression) => {
+            return expression.getText().includes(name);
+        });
+        if (!has) {
+            sourceFile.addImportDeclaration({
+                moduleSpecifier,
+                namedImports: [{ name: name }]
+            });
+            extendsConfig.addElement("\n" + content);
+        }
+    }
+    findConfigurationDecorationOptions() {
+        if (!this.serverSourceFile) {
+            return;
+        }
+        return this.findClassDecorator(this.serverSourceFile, "Configuration")?.getArguments().at(0);
+    }
+    findConfigConfiguration() {
+        const sourceFile = this.configSourceFile;
+        if (!sourceFile) {
+            return;
+        }
+        return sourceFile.getVariableDeclaration("config")?.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    }
+    findBinConfiguration() {
+        if (!this.binSourceFile) {
+            return;
+        }
+        for (const child of this.binSourceFile.getStatements()) {
+            if (child.getKind() === SyntaxKind.ExpressionStatement && child.getText().includes("CliCore.bootstrap")) {
+                return child.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
+            }
+        }
+        return undefined;
+    }
+}

package/lib/esm/services/mappers/addContextMethods.js

@@ -0,0 +1,17 @@
+import { inject } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
+import { pascalCase } from "change-case";
+import { RoutePipe } from "../../pipes/RoutePipe.js";
+import { CliProjectService } from "../CliProjectService.js";
+export function addContextMethods(context) {
+    const getName = (state) => context.name || pascalCase(state.name || context.name || state.type || context.type || "");
+    return {
+        getName,
+        getRoute: (state) => {
+            return inject(RoutePipe).transform(isString(state) ? state : getName(state));
+        },
+        getDirectories: (dir) => {
+            return inject(CliProjectService).getDirectories(dir);
+        }
+    };
+}

package/lib/esm/services/mappers/mapDefaultTemplateOptions.js

@@ -0,0 +1,36 @@
+import { inject, ProjectPackageJson } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
+import { normalizePath } from "@tsed/normalize-path";
+import { pascalCase } from "change-case";
+import { ProjectConvention } from "../../interfaces/ProjectConvention.js";
+import { OutputFilePathPipe } from "../../pipes/OutputFilePathPipe.js";
+import { RoutePipe } from "../../pipes/RoutePipe.js";
+import { SymbolNamePipe } from "../../pipes/SymbolNamePipe.js";
+import { CliProjectService } from "../CliProjectService.js";
+import { addContextMethods } from "./addContextMethods.js";
+export function mapDefaultTemplateOptions(opts) {
+    const classNamePipe = inject(SymbolNamePipe);
+    const outputFilePathPipe = inject(OutputFilePathPipe);
+    const projectPackageJson = inject(ProjectPackageJson);
+    const { name = "" } = opts;
+    let { type = "" } = opts;
+    type = type.toLowerCase();
+    if (opts.name === "prisma" && opts.name) {
+        type = "prisma.service";
+    }
+    const symbolName = opts.symbolName || classNamePipe.transform({ name, type, format: ProjectConvention.DEFAULT });
+    const symbolPath = opts.symbolPath ||
+        normalizePath(outputFilePathPipe.transform({
+            name,
+            type,
+            subDir: opts.directory
+        }));
+    return {
+        ...projectPackageJson.fillWithPreferences(opts),
+        type,
+        symbolName,
+        symbolPath,
+        symbolPathBasename: opts.symbolPathBasename || normalizePath(classNamePipe.transform({ name, type })),
+        ...addContextMethods(opts)
+    };
+}

package/lib/esm/templates/asyncFactory.template.js

@@ -0,0 +1,38 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { camelCase, pascalCase } from "change-case";
+export default defineTemplate({
+    id: "async.factory",
+    label: "Async Factory",
+    fileName: "{{symbolName}}.factory?",
+    outputDir: "{{srcDir}}/services",
+    render(symbolName) {
+        const camelName = camelCase(symbolName);
+        const optName = pascalCase(symbolName + "Options");
+        return `import {injectable} from "@tsed/di";
+
+interface ${optName} {
+  
+}
+    
+declare global {
+  namespace TsED {
+    interface Configuration extends Record<string, any> {
+      ${camelName}: Options;
+    }
+  }
+}    
+
+export const ${symbolName} = injectable(Symbol.for("${symbolName}"))
+  .factory(async () => {
+    const myConstant = constant<${optName}>("${camelName}");
+    
+    // do something async
+    await Promise.resolve();
+    
+    return {};
+  })
+  .token();
+  
+export type {{symbolName}} = typeof ${symbolName};`;
+    }
+});

package/lib/esm/templates/barrels.template.js

@@ -0,0 +1,27 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { $alter } from "@tsed/hooks";
+export default defineTemplate({
+    id: "barrels",
+    label: "Barrels",
+    description: "Create barrels files (index.ts) to simplify imports.",
+    fileName: ".barrels",
+    ext: "json",
+    outputDir: ".",
+    hidden: true,
+    preserveCase: true,
+    prompts() {
+        return [];
+    },
+    render(_, context) {
+        const barrels = $alter("$alterBarrels", {
+            directory: [
+                "./src/controllers/rest",
+                context.commands && "./src/bin/commands",
+                (context.swagger || context.oidc) && "./src/controllers/pages"
+            ].filter(Boolean),
+            exclude: ["**/__mock__", "**/__mocks__", "**/*.spec.ts"],
+            delete: true
+        });
+        return JSON.stringify(barrels, null, 2);
+    }
+});

package/lib/esm/templates/command.template.js

@@ -0,0 +1,56 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { kebabCase } from "change-case";
+export default defineTemplate({
+    id: "command",
+    label: "Command",
+    fileName: "{{symbolName}}.command",
+    outputDir: "{{srcDir}}/bin/commands",
+    render(symbolName) {
+        const symbolParamName = kebabCase(symbolName);
+        return `import {Command, CommandProvider, QuestionOptions} from "@tsed/cli-core";
+
+export interface ${symbolName}Context {
+}
+
+@Command({
+  name: "${symbolParamName}",
+  description: "Command description",
+  args: {
+  },
+  options: {
+  },
+  allowUnknownOption: false
+})
+export class ${symbolName} implements CommandProvider {
+  /**
+   *  Ask questions with Inquirer. Return an empty array or don't implement the method to skip this step
+   */
+  async $prompt(initialOptions: Partial<${symbolName}Context>): Promise<QuestionOptions> {
+    return [];
+  }
+
+  /**
+   * This method is called after the $prompt to create / map inputs to a proper context for the next step
+   */
+  $mapContext(ctx: Partial<${symbolName}Context>): ${symbolName}Context {
+    return {
+      ...ctx
+      // map something, based on ctx
+    };
+  }
+  /**
+   *  This step run your tasks with Listr module
+   */
+  async $exec(ctx: ${symbolName}Context): Promise<any> {
+    return [
+      {
+        title: "Do something",
+        task: () => {
+          console.log('HELLO')
+        }
+      }
+    ];
+  }
+}`;
+    }
+});

package/lib/esm/templates/config.template.js

@@ -0,0 +1,27 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "config",
+    label: "Config",
+    description: "Create a new config file",
+    outputDir: "{{srcDir}}/config",
+    fileName: "config",
+    hidden: true,
+    preserveCase: true,
+    render() {
+        return `import {readFileSync} from "node:fs";
+import loggerConfig from "./logger/index.js";
+
+const pkg = JSON.parse(readFileSync("./package.json", {encoding: "utf8"}));
+/**
+ * This is the shared configuration for the application
+ */
+export const config: Partial<TsED.Configuration> = {
+  version: pkg.version,
+  ajv: {
+    returnsCoercedValues: true
+  },
+  logger: loggerConfig
+};
+`;
+    }
+});

package/lib/esm/templates/controller.template.js

@@ -0,0 +1,44 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "controller",
+    label: "Controller",
+    fileName: "{{symbolName}}.controller",
+    outputDir: "{{srcDir}}/controllers",
+    prompts(context) {
+        return [
+            {
+                type: "list",
+                name: "directory",
+                message: "Which directory?",
+                when(state) {
+                    return !!(["controller"].includes(state.type || context.type) || context.directory);
+                },
+                choices: context.getDirectories("controllers")
+            },
+            {
+                type: "input",
+                name: "route",
+                message: "Which route?",
+                when(state) {
+                    return !!(["controller"].includes(state.type || context.type) || context.route);
+                },
+                default: (state) => {
+                    return context.getRoute(state);
+                }
+            }
+        ];
+    },
+    render(symbolName, context) {
+        const route = context.getRoute(context.route);
+        return `import {Controller} from "@tsed/di";
+import {Get} from "@tsed/schema";
+
+@Controller("${route}")
+export class ${symbolName} {
+  @Get("/")
+  get() {
+    return "hello";
+  }
+}`;
+    }
+});

package/lib/esm/templates/decorator.template.js

@@ -0,0 +1,184 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "decorator",
+    label: "Decorator",
+    fileName: "{{symbolName}}",
+    outputDir: "{{srcDir}}/decorators",
+    prompts(context) {
+        return [
+            {
+                type: "list",
+                name: "templateType",
+                message: "What kind of decorator do you want to create?",
+                when(state) {
+                    return !!(["decorator"].includes(state.type || context.type) || context.templateType);
+                },
+                choices: [
+                    { name: "Class Decorator", value: "class" },
+                    { name: "Generic Decorator (class, property)", value: "generic" },
+                    { name: "Method Decorator", value: "method" },
+                    { name: "Parameter Decorator", value: "param" },
+                    { name: "Property Decorator", value: "property" },
+                    { name: "Property Decorator (with @Property)", value: "prop" },
+                    { name: "Parameters Decorator", value: "parameters" },
+                    { name: "Endpoint Decorator", value: "endpoint" },
+                    { name: "Middleware Decorator", value: "middleware" }
+                ],
+                default: "class"
+            }
+        ];
+    },
+    render(symbolName, context) {
+        const type = context.templateType || "class";
+        switch (type) {
+            case "class":
+                return `
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options): ClassDecorator {
+  return (target: any): any => {
+    return class extends target {
+      constructor(...args: any[]) {
+        super(...args);
+      }
+    };
+  };
+}
+`;
+            case "generic":
+                return `import {DecoratorTypes, UnsupportedDecoratorType, decoratorTypeOf} from "@tsed/core";
+
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options): any {
+  return (...args: DecoratorParameters): any => {
+    switch(decoratorTypeOf(args)) {
+      case DecoratorTypes.CLASS:
+      case DecoratorTypes.PROP:
+        console.log("do something")
+        break;
+
+      default:
+        throw new UnsupportedDecoratorType(${symbolName}, args);
+    }
+  };
+}
+`;
+            case "method":
+                return `
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options): MethodDecorator {
+  return (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>): TypedPropertyDescriptor<any> | void => {
+    console.log("do something");
+    return descriptor;
+  };
+}
+`;
+            case "param":
+                return `import {ParamTypes, useDecorators} from "@tsed/core";
+import {UsePipe} from "@tsed/platform-params";
+
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options): ParameterDecorator {
+  return useDecorators(
+    UsePipe(${symbolName}Pipe),
+    ParamTypes("${symbolName.toLowerCase()}")
+  );
+}
+`;
+            case "property":
+                return `
+export function ${symbolName}(): PropertyDecorator {
+  return (target: Object, propertyKey: string | symbol): void => {
+    console.log("do something");
+  };
+}
+`;
+            case "prop":
+                return `import {useDecorators} from "@tsed/core";
+import {Property} from "@tsed/schema";
+
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options = {}): PropertyDecorator {
+  return useDecorators(
+    Property()
+  );
+}
+`;
+            case "parameters":
+                return `
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options): ParameterDecorator {
+  return (target: Object, propertyKey: string | symbol, parameterIndex: number): void => {
+    console.log("do something");
+  };
+}
+`;
+            case "endpoint":
+                return `import {useDecorators} from "@tsed/core";
+import {Get} from "@tsed/schema";
+
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options = {}): MethodDecorator {
+  return useDecorators(
+    Get("/")
+  );
+}
+`;
+            case "middleware":
+                return `import {Context} from "@tsed/platform-params";
+import {Middleware, MiddlewareMethods} from "@tsed/platform-middlewares";
+import {Next} from "@tsed/common";
+
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options = {}): ClassDecorator {
+  return (target: any) => {
+    @Middleware()
+    class ${symbolName}Middleware implements MiddlewareMethods {
+      use(@Context() ctx: Context, @Next() next: Next) {
+        // do something
+        return next();
+      }
+    }
+
+    return target;
+  };
+}
+`;
+            default:
+                return `
+export interface ${symbolName}Options {
+
+}
+
+export function ${symbolName}(options: ${symbolName}Options): any {
+  return (...args: any[]): any => {
+    console.log("do something");
+  };
+}
+`;
+        }
+    }
+});

package/lib/esm/templates/docker-compose.template.js

@@ -0,0 +1,25 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "docker-compose.yml",
+    label: "Docker Compose",
+    description: "Create a docker-compose.yml file.",
+    fileName: "docker-compose",
+    outputDir: ".",
+    ext: "yml",
+    preserveCase: true,
+    render(_, context) {
+        return `services:
+  server:
+    build:
+      context: .
+      dockerfile: ./Dockerfile
+      args:
+        - http_proxy
+        - https_proxy
+        - no_proxy
+    image: ${context.projectName}/server:latest
+    ports:
+      - "8081:8081"
+`;
+    }
+});