@tsed/cli 6.6.3 → 7.0.0-alpha.10

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

@@ -0,0 +1,236 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+function dockerHeader() {
+    return `###############################################################################
+###############################################################################
+##                      _______ _____ ______ _____                           ##
+##                     |__   __/ ____|  ____|  __ \\                          ##
+##                        | | | (___ | |__  | |  | |                         ##
+##                        | |  \\___ \\|  __| | |  | |                         ##
+##                        | |  ____) | |____| |__| |                         ##
+##                        |_| |_____/|______|_____/                          ##
+##                                                                           ##
+## description     : Dockerfile for TsED Application                         ##
+## author          : TsED team                                               ##
+## date            : 2023-12-11                                              ##
+## version         : 3.0                                                     ##
+##                                                                           ##
+###############################################################################
+###############################################################################
+`;
+}
+function dockerDevTools() {
+    return `RUN apk update && apk add build-base git curl
+RUN npm install -g pm2
+`;
+}
+function dockerBody() {
+    return `COPY . .
+
+EXPOSE 8081
+ENV PORT 8081
+ENV NODE_ENV production`;
+}
+defineTemplate({
+    id: "dockerfile.yarn",
+    label: "Dockerfile (Yarn classic)",
+    fileName: "Dockerfile",
+    outputDir: ".",
+    ext: null,
+    preserveCase: true,
+    render() {
+        return `${dockerHeader()}
+
+ARG NODE_VERSION=20.11.0
+
+FROM node:\${NODE_VERSION}-alpine AS build
+WORKDIR /opt
+
+COPY package.json yarn.lock tsconfig.json tsconfig.base.json tsconfig.node.json tsconfig.spec.json .barrels.json .swcrc ./
+
+RUN yarn install --pure-lockfile
+
+COPY ./src ./src
+
+RUN yarn build
+
+FROM node:\${NODE_VERSION}-alpine AS runtime
+ENV WORKDIR /opt
+WORKDIR $WORKDIR
+
+${dockerDevTools()}
+
+COPY --from=build /opt .
+
+RUN yarn install --pure-lockfile --production
+
+${dockerBody()}
+
+CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]
+`;
+    }
+});
+defineTemplate({
+    id: "dockerfile.yarn_berry",
+    label: "Dockerfile (Yarn Berry)",
+    fileName: "Dockerfile",
+    outputDir: ".",
+    ext: null,
+    preserveCase: true,
+    render() {
+        return `${dockerHeader()}
+
+ARG NODE_VERSION=20.11.0
+
+FROM node:\${NODE_VERSION}-alpine AS build
+WORKDIR /opt
+
+COPY package.json yarn.lock tsconfig.json tsconfig.base.json tsconfig.node.json tsconfig.spec.json .barrels.json .swcrc ./
+
+RUN yarn set version berry
+RUN yarn install --immutable
+
+COPY ./src ./src
+
+RUN yarn build
+
+FROM node:\${NODE_VERSION}-alpine AS runtime
+ENV WORKDIR /opt
+WORKDIR $WORKDIR
+
+${dockerDevTools()}
+
+COPY --from=build /opt .
+
+RUN yarn set version berry
+RUN yarn install --immutable
+## RUN yarn workspaces focus --all --production
+
+${dockerBody()}
+
+CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]
+`;
+    }
+});
+defineTemplate({
+    id: "dockerfile.npm",
+    label: "Dockerfile (NPM)",
+    fileName: "Dockerfile",
+    outputDir: ".",
+    ext: null,
+    preserveCase: true,
+    render() {
+        return `${dockerHeader()}
+
+ARG NODE_VERSION=20.11.0
+
+FROM node:\${NODE_VERSION}-alpine AS build
+WORKDIR /opt
+
+COPY package.json package-lock.json tsconfig.json tsconfig.base.json tsconfig.node.json tsconfig.spec.json .barrels.json .swcrc ./
+
+RUN npm ci
+
+COPY ./src ./src
+
+RUN npm run build
+
+FROM node:\${NODE_VERSION}-alpine AS runtime
+ENV WORKDIR /opt
+WORKDIR $WORKDIR
+
+${dockerDevTools()}
+
+COPY --from=build /opt .
+
+RUN npm ci --omit=dev --ignore-scripts
+
+${dockerBody()}
+
+CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]`;
+    }
+});
+defineTemplate({
+    id: "dockerfile.pnpm",
+    label: "Dockerfile (PNPM)",
+    fileName: "Dockerfile",
+    outputDir: ".",
+    ext: null,
+    preserveCase: true,
+    render() {
+        return `${dockerHeader()}
+
+ARG NODE_VERSION=20.11.0
+
+FROM node:\${NODE_VERSION}-alpine AS build
+WORKDIR /opt
+
+COPY package.json pnpm-lock.yaml tsconfig.json tsconfig.base.json tsconfig.node.json tsconfig.spec.json .barrels.json .swcrc ./
+
+RUN pnpm install --frozen-lockfile
+
+COPY ./src ./src
+
+RUN pnpm run build
+
+FROM node:\${NODE_VERSION}-alpine AS runtime
+ENV WORKDIR /opt
+WORKDIR $WORKDIR
+
+${dockerDevTools()}
+
+COPY --from=build /opt .
+
+RUN pnpm install --frozen-lockfile --prod
+
+${dockerBody()}
+
+CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]
+`;
+    }
+});
+defineTemplate({
+    id: "dockerfile.bun",
+    label: "Dockerfile (Bun)",
+    fileName: "Dockerfile",
+    outputDir: ".",
+    ext: null,
+    preserveCase: true,
+    render() {
+        return `
+ARG BUN_VERSION=1
+
+FROM oven/bun:\${BUN_VERSION} AS base
+WORKDIR /opt
+
+FROM base AS install
+RUN mkdir -p /temp/dev
+COPY package.json bun.lockb /temp/dev/
+RUN cd /temp/dev && bun install --frozen-lockfile
+
+# install with --production (exclude devDependencies)
+RUN mkdir -p /temp/prod
+COPY package.json bun.lockb /temp/prod/
+RUN cd /temp/prod && bun install --frozen-lockfile --production
+
+# copy node_modules from temp directory
+# then copy all (non-ignored) project files into the image
+FROM base AS prerelease
+COPY --from=install /temp/dev/node_modules node_modules
+COPY . .
+
+RUN bun run build
+
+# copy production dependencies and source code into final image
+FROM base AS release
+COPY --from=install /temp/prod/node_modules node_modules
+COPY --from=prerelease /opt/dist/index.js .
+COPY --from=prerelease /opt/package.json .
+
+USER bun
+
+${dockerBody()}
+
+CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production", "--interpreter", "~/.bun/bin/bun"]
+`;
+    }
+});

package/lib/esm/templates/exception-filter.template.js

@@ -0,0 +1,19 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "exception-filter",
+    label: "Exception Filter",
+    fileName: "{{symbolName}}.exception-filter",
+    outputDir: "{{srcDir}}/filters",
+    render(symbolName) {
+        return `import {BaseContext} from "@tsed/di";
+import {Catch, ExceptionFilterMethods} from "@tsed/platform-exceptions";
+
+@Catch(Error)
+export class ${symbolName} implements ExceptionFilterMethods {
+   catch(exception: Exception, ctx: BaseContext) {
+
+   }
+}
+`;
+    }
+});

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

@@ -0,0 +1,37 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { camelCase, pascalCase } from "change-case";
+export default defineTemplate({
+    id: "factory",
+    label: "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(() => {
+    const myConstant = constant<${optName}>("${camelName}");
+    
+    // do something
+    
+    return {};
+  })
+  .token();
+  
+export type {{symbolName}} = typeof ${symbolName};`;
+    }
+});

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

@@ -0,0 +1,22 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "index.command",
+    label: "CLI Entry Point",
+    description: "Create a new CLI entry point file",
+    outputDir: "{{srcDir}}/bin",
+    fileName: "index",
+    hidden: true,
+    preserveCase: true,
+    render() {
+        return `#!/usr/bin/env node
+import {CliCore} from "@tsed/cli-core";
+import {config} from "@/config/config.js";
+import * commands from "@/bin/commands/index.js";
+
+CliCore.bootstrap({
+  ...config,
+  commands: [...Object.values(commands)]
+}).catch(console.error);
+`;
+    }
+});

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

@@ -0,0 +1,17 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "index.config.util",
+    label: "Is Production utility",
+    type: "util",
+    description: "Create a utility to check if the environment is production",
+    fileName: "index",
+    outputDir: "{{srcDir}}/config/utils",
+    preserveCase: true,
+    hidden: true,
+    render() {
+        return `process.env.NODE_ENV = process.env.NODE_ENV || "development";
+
+export const isProduction = process.env.NODE_ENV === "production";
+`;
+    }
+});

package/{templates/init/src/controllers/pages/IndexController.ts.hbs → lib/esm/templates/index.controller.template.js}

@@ -1,4 +1,13 @@
-import {Constant, Controller} from "@tsed/di";
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "index.controller",
+    label: "Index Controller",
+    description: "Create a new index controller file",
+    outputDir: "{{srcDir}}/controllers/pages",
+    fileName: "index.controller",
+    hidden: true,
+    render() {
+        return `import {Constant, Controller} from "@tsed/di";
 import {HeaderParams} from "@tsed/platform-params";
 import {View} from "@tsed/platform-views";
 import {SwaggerSettings} from "@tsed/swagger";
@@ -14,7 +23,7 @@ export class IndexController {
   @View("swagger.ejs")
   @(Returns(200, String).ContentType("text/html"))
   get(@HeaderParams("x-forwarded-proto") protocol: string, @HeaderParams("host") host: string) {
-    const hostUrl = `${protocol || "http"}://${host}`;
+    const hostUrl = \`\${protocol || "http"}://\${host}\`;
 
     return {
       BASE_URL: hostUrl,
@@ -26,4 +35,6 @@ export class IndexController {
       })
     };
   }
-}
+}`;
+    }
+});

package/lib/esm/templates/index.js

@@ -0,0 +1,32 @@
+// Import all templates to register them with the DI container
+import "./asyncFactory.template.js";
+import "./command.template.js";
+import "./controller.template.js";
+import "./decorator.template.js";
+import "./exception-filter.template.js";
+import "./factory.template.js";
+import "./interface.template.js";
+import "./interceptor.template.js";
+import "./middleware.template.js";
+import "./model.template.js";
+import "./module.template.js";
+import "./pipe.template.js";
+import "./prisma.service.template.js";
+import "./repository.template.js";
+import "./response-filter.template.js";
+import "./service.template.js";
+import "./value.template.js";
+import "./barrels.template.js";
+import "./server.template.js";
+import "./config.template.js";
+import "./index.template.js";
+import "./index.controller.template.js";
+import "./index.command.template.js";
+import "./index.logger.template.js";
+import "./index.config.utils.template.js";
+import "./tsconfig.spec.template.js";
+import "./docker-compose.template.js";
+import "./dockerfile.template.js";
+import "./pm2.template.js";
+import "./readme.template.js";
+import "./new-template.template.js";

package/lib/esm/templates/index.logger.template.js

@@ -0,0 +1,41 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { ProjectConvention } from "../interfaces/index.js";
+export default defineTemplate({
+    id: "index.logger",
+    label: "Logger",
+    description: "Create a new logger configuration file",
+    outputDir: "{{srcDir}}/config/logger",
+    fileName: "index",
+    preserveCase: true,
+    hidden: true,
+    render() {
+        return `import "@tsed/logger-std";
+import "@tsed/logger/layouts/JsonLayout.js";
+import {DILoggerOptions} from "@tsed/di";
+import {$log} from "@tsed/logger";
+import {isProduction} from "../utils/index.js";
+
+if (isProduction) {
+  $log.appenders.set("stdout", {
+    type: "stdout",
+    levels: ["info", "debug"],
+    layout: {
+      type: "json"
+    }
+  });
+
+  $log.appenders.set("stderr", {
+    levels: ["trace", "fatal", "error", "warn"],
+    type: "stderr",
+    layout: {
+      type: "json"
+    }
+  });
+}
+
+export default <DILoggerOptions>{
+  disableRoutesSummary: isProduction
+};
+`;
+    }
+});

package/{templates/init/src/index.ts.hbs → lib/esm/templates/index.template.js}

@@ -1,6 +1,15 @@
-import {$log} from "@tsed/logger";
-import { {{platformSymbol}} } from "@tsed/platform-{{platform}}";
-import {Server} from "./{{entryServer}}.js";
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "index",
+    label: "Main index application file",
+    description: "Create a new main index application file",
+    outputDir: "{{srcDir}}",
+    fileName: "index",
+    hidden: true,
+    preserveCase: true,
+    render() {
+        return `import {$log} from "@tsed/logger";
+import {PlatformBuilder} from "@tsed/platform-http";
 
 const SIG_EVENTS = [
   "beforeExit",
@@ -19,7 +28,8 @@ const SIG_EVENTS = [
 ];
 
 try {
-  const platform = await {{platformSymbol}}.bootstrap(Server);
+  const platform = await PlatformBuilder.bootstrap(Server);
+
   await platform.listen();
 
   SIG_EVENTS.forEach((evt) => process.on(evt, () => platform.stop()));
@@ -33,4 +43,6 @@ try {
 } catch (error) {
   $log.error({event: "SERVER_BOOTSTRAP_ERROR", message: error.message, stack: error.stack});
 }
-
+`;
+    }
+});

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

@@ -0,0 +1,31 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "interceptor",
+    label: "Interceptor",
+    fileName: "{{symbolName}}.interceptor",
+    outputDir: "{{srcDir}}/interceptors",
+    render(symbolName) {
+        return `import {InterceptorMethods, InterceptorContext, InterceptorMethods, Interceptor} from "@tsed/di";
+
+@Interceptor()
+export class ${symbolName} implements InterceptorMethods {
+  /**
+   * ctx: The context that holds the dynamic data related to the method execution and the proceed method
+   * to proceed with the original method execution
+   *
+   * opts: Static params that can be provided when the interceptor is attached to a specific method
+   */
+  async intercept(context: InterceptorContext<any>, next: InterceptorMethods) {
+    console.log(\`the method \${context.propertyKey} will be executed with args \${context.args} and static data \${context.options}\`);
+    // let the original method by calling next function
+    const result = await next();
+
+    console.log(\`the method was executed, and returned \${result}\`);
+
+    // must return the returned value back to the caller
+    return result;
+  }
+}
+`;
+    }
+});

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

@@ -0,0 +1,13 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "interface",
+    label: "Interface",
+    fileName: "{{symbolName}}.interface",
+    outputDir: "{{srcDir}}/interfaces",
+    render(symbolName) {
+        return `export interface ${symbolName} {
+
+}
+`;
+    }
+});

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

@@ -0,0 +1,36 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "middleware",
+    label: "Middleware",
+    fileName: "{{symbolName}}.middleware",
+    outputDir: "{{srcDir}}/middlewares",
+    prompts(context) {
+        return [
+            {
+                type: "list",
+                name: "middlewarePosition",
+                message: () => `The middleware should be called:`,
+                choices: [
+                    { name: "Before the endpoint", value: "before" },
+                    { name: "After the endpoint", value: "after" }
+                ],
+                when(state) {
+                    return !!((["decorator"].includes(state.type || context.type) && ["middleware"].includes(state.templateType)) ||
+                        context.middlewarePosition);
+                }
+            }
+        ];
+    },
+    render(symbolName) {
+        return `import {Middleware, MiddlewareMethods} from "@tsed/platform-middlewares";
+import {Context} from "@tsed/platform-params";
+
+@Middleware()
+export class ${symbolName} implements MiddlewareMethods {
+  use(@Context() ctx: Context) {
+
+  }
+}
+`;
+    }
+});

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

@@ -0,0 +1,16 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "model",
+    label: "Model",
+    fileName: "{{symbolName}}.model",
+    outputDir: "{{srcDir}}/models",
+    render(symbolName) {
+        return `import {Property} from "@tsed/schema";
+
+export class ${symbolName} {
+  @Property()
+  id: string;
+}
+`;
+    }
+});

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

@@ -0,0 +1,16 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "module",
+    label: "Module",
+    fileName: "{{symbolName}}.module",
+    outputDir: "{{srcDir}}",
+    render(symbolName) {
+        return `import {Module} from "@tsed/di";
+
+@Module()
+export class ${symbolName} {
+
+}
+`;
+    }
+});

package/lib/esm/templates/new-template.template.js

@@ -0,0 +1,67 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+defineTemplate({
+    id: "new-template",
+    label: "New Template",
+    fileName: "{{symbolName}}.template",
+    preserveCase: true,
+    outputDir: "./.templates",
+    hidden: true,
+    render(_, context) {
+        if (context.from === "new") {
+            return `import {defineTemplate} from "@tsed/cli";
+    
+export default defineTemplate({
+  id: "${context.templateId}",
+  label: "${context.name}",
+  fileName: "{{symbolName}}.services",
+  outputDir: "{{srcDir}}/services",
+  render(symbolName, context) {
+    return \`export class \${symbolName} {}\`
+  }
+});`;
+        }
+        if (context.template) {
+            const { id, ...props } = context.template;
+            const render = props.render.toString();
+            if (render.includes(""))
+                return `import {defineTemplate} from "@tsed/cli";      
+    
+defineTemplate({
+  id: "${context.override ? id : context.templateId}",
+  label: "${context.name}",
+  fileName: "${props.fileName}",
+  outputDir: "${props.outputDir}",
+  ${props.prompts ? `${props.prompts.toString()},` : ""}
+  ${props.render.toString()}
+});`;
+        }
+    },
+    hooks: {
+        $afterCreateSourceFile(sourceFile) {
+            const sourceFileText = sourceFile.getFullText();
+            if (sourceFileText.includes("camelCase")) {
+                sourceFile.addImportDeclaration({
+                    namedImports: ["camelCase"],
+                    moduleSpecifier: "change-case"
+                });
+            }
+            if (sourceFileText.includes("pascalCase")) {
+                sourceFile.addImportDeclaration({
+                    namedImports: ["pascalCase"],
+                    moduleSpecifier: "change-case"
+                });
+            }
+            if (sourceFileText.includes("kebabCase")) {
+                sourceFile.addImportDeclaration({
+                    namedImports: ["kebabCase"],
+                    moduleSpecifier: "change-case"
+                });
+            }
+            sourceFile.formatText({
+                indentSize: 2
+            });
+            sourceFile.saveSync();
+            return sourceFile;
+        }
+    }
+});

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

@@ -0,0 +1,19 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "pipe",
+    label: "Pipe",
+    fileName: "{{symbolName}}.pipe",
+    outputDir: "{{srcDir}}/pipes",
+    render(symbolName) {
+        return `import {Injectable} from "@tsed/di";
+import {PipeMethods, ParamMetadata} from "@tsed/platform-params";
+
+@Injectable()
+export class ${symbolName} extends PipeMethods {
+  transform(value: any, param: ParamMetadata) {
+    return null;
+  }
+}
+`;
+    }
+});