@tsed/cli-plugin-typeorm 6.6.3 → 7.0.0-alpha.1

package/lib/esm/CliPluginTypeORMModule.js

@@ -1,26 +1,18 @@
-import { __decorate, __metadata } from "tslib";
-import { inject, Module, OnAdd, ProjectPackageJson } from "@tsed/cli-core";
+import { inject, ProjectPackageJson } from "@tsed/cli-core";
+import { injectable } from "@tsed/di";
 import { TypeORMGenerateHook } from "./hooks/TypeORMGenerateHook.js";
 import { TypeORMInitHook } from "./hooks/TypeORMInitHook.js";
-let CliPluginTypeORMModule = class CliPluginTypeORMModule {
+export class CliPluginTypeORMModule {
     constructor() {
         this.packageJson = inject(ProjectPackageJson);
     }
-    install() {
-        this.packageJson.addDependencies({
-            typeorm: "latest"
-        });
+    $alterPackageJson(packageJson, data) {
+        if (data.typeorm) {
+            packageJson.addDependencies({
+                typeorm: "latest"
+            });
+        }
+        return packageJson;
     }
-};
-__decorate([
-    OnAdd("@tsed/cli-plugin-typeorm"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], CliPluginTypeORMModule.prototype, "install", null);
-CliPluginTypeORMModule = __decorate([
-    Module({
-        imports: [TypeORMInitHook, TypeORMGenerateHook]
-    })
-], CliPluginTypeORMModule);
-export { CliPluginTypeORMModule };
+}
+injectable(CliPluginTypeORMModule).imports([TypeORMInitHook, TypeORMGenerateHook]);

package/lib/esm/hooks/TypeORMGenerateHook.js

@@ -1,107 +1,34 @@
-var TypeORMGenerateHook_1;
-import { __decorate, __metadata } from "tslib";
-import { FeaturesMap, ProvidersInfoService, SrcRendererService } from "@tsed/cli";
-import { CliDockerComposeYaml, inject, OnExec, OnPrompt, ProjectPackageJson } from "@tsed/cli-core";
-import { Injectable } from "@tsed/di";
-import { camelCase } from "change-case";
-import { TEMPLATE_DIR } from "../utils/templateDir.js";
-let TypeORMGenerateHook = TypeORMGenerateHook_1 = class TypeORMGenerateHook {
-    constructor(providersInfoService) {
-        this.providersInfoService = providersInfoService;
+import {} from "@tsed/cli";
+import { CliDockerComposeYaml, ProjectPackageJson } from "@tsed/cli-core";
+import { inject, injectable } from "@tsed/di";
+import { getDatabase, getTypeORMDatabases } from "../utils/getTypeORMDatabases.js";
+export class TypeORMGenerateHook {
+    constructor() {
         this.projectPackageJson = inject(ProjectPackageJson);
-        this.srcRenderService = inject(SrcRendererService);
         this.cliDockerComposeYaml = inject(CliDockerComposeYaml);
-        providersInfoService.add({
-            name: "TypeORM Datasource",
-            value: "typeorm:datasource",
-            model: "{{symbolName}}.datasource"
-        }, TypeORMGenerateHook_1);
     }
-    onGeneratePrompt() {
-        const list = this.getTypeORMTypes().map(([value, { name }]) => {
-            return {
-                name: name,
-                value: value
-            };
-        });
-        return [
-            {
-                type: "autocomplete",
-                name: "typeormDataSource",
-                message: "Which database type?",
-                when(state) {
-                    return state.type === "typeorm:datasource";
-                },
-                source: (state, keyword) => {
-                    if (keyword) {
-                        return list.filter((item) => item.name.toLowerCase().includes(keyword.toLowerCase()));
-                    }
-                    return list;
+    $alterGenerateTasks(tasks, data) {
+        const { typeormDataSource, name } = data;
+        if (typeormDataSource) {
+            getTypeORMDatabases()
+                .filter(([value]) => value === typeormDataSource)
+                .forEach(([, feature]) => {
+                if (feature.dependencies) {
+                    this.projectPackageJson.addDependencies(feature.dependencies);
                 }
-            }
-        ];
-    }
-    onGenerateExec(ctx) {
-        if (this.providersInfoService.isMyProvider(ctx.type, TypeORMGenerateHook_1)) {
-            return this.generateDataSourceTasks(ctx);
-        }
-        return [];
-    }
-    getTypeORMTypes() {
-        return Object.entries(FeaturesMap).filter(([value]) => value.startsWith("typeorm:"));
-    }
-    generateDataSourceTasks(ctx) {
-        const { typeormDataSource, symbolPath, name } = ctx;
-        if (!typeormDataSource) {
-            return [];
+                if (feature.devDependencies) {
+                    this.projectPackageJson.addDependencies(feature.devDependencies);
+                }
+            });
         }
-        this.getTypeORMTypes()
-            .filter(([value]) => value === typeormDataSource)
-            .forEach(([, feature]) => {
-            if (feature.dependencies) {
-                this.projectPackageJson.addDependencies(feature.dependencies);
-            }
-            if (feature.devDependencies) {
-                this.projectPackageJson.addDependencies(feature.devDependencies);
-            }
-        });
-        const database = typeormDataSource.split(":").at(-1);
-        const symbolName = ctx.symbolName;
         return [
-            {
-                title: `Generate TypeORM datasource file to '${symbolPath}.ts'`,
-                task: () => this.srcRenderService.render("datasource.hbs", {
-                    name,
-                    database,
-                    symbolName,
-                    instanceName: camelCase(symbolName)
-                }, {
-                    templateDir: TEMPLATE_DIR,
-                    output: `${ctx.symbolPath}.ts`,
-                    rootDir: this.srcRenderService.rootDir
-                })
-            },
+            ...tasks,
             {
                 title: "Generate docker-compose configuration",
-                task: () => this.cliDockerComposeYaml.addDatabaseService(name, database)
+                enabled: () => !!typeormDataSource,
+                task: () => this.cliDockerComposeYaml.addDatabaseService(name, getDatabase(data))
             }
         ];
     }
-};
-__decorate([
-    OnPrompt("generate"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], TypeORMGenerateHook.prototype, "onGeneratePrompt", null);
-__decorate([
-    OnExec("generate"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Array)
-], TypeORMGenerateHook.prototype, "onGenerateExec", null);
-TypeORMGenerateHook = TypeORMGenerateHook_1 = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [ProvidersInfoService])
-], TypeORMGenerateHook);
-export { TypeORMGenerateHook };
+}
+injectable(TypeORMGenerateHook);

package/lib/esm/hooks/TypeORMInitHook.js

@@ -1,49 +1,46 @@
-import { __decorate, __metadata } from "tslib";
-import { CliService, inject, OnExec, ProjectPackageJson } from "@tsed/cli-core";
-import { Injectable } from "@tsed/di";
+import { ProjectClient } from "@tsed/cli";
+import { CliService, inject, ProjectPackageJson } from "@tsed/cli-core";
+import { injectable } from "@tsed/di";
 import { pascalCase } from "change-case";
 function getDatabase(ctx) {
-    return ctx.features.find((type) => type.includes("typeorm:"))?.split(":")[1] || "";
+    return ctx.features?.find((type) => type.includes("typeorm:"))?.split(":")[1];
 }
-let TypeORMInitHook = class TypeORMInitHook {
+export class TypeORMInitHook {
     constructor() {
         this.cliService = inject(CliService);
-        this.packageJson = inject(ProjectPackageJson);
     }
-    onExec(ctx) {
-        this.addScripts();
-        this.addDependencies(ctx);
-        this.addDevDependencies(ctx);
-        const database = getDatabase(ctx);
-        if (!database) {
-            return [];
+    $alterPackageJson(packageJson, data) {
+        if (data.typeorm) {
+            packageJson.addScripts({
+                typeorm: "typeorm-ts-node-commonjs"
+            });
         }
-        return this.cliService.getTasks("generate", {
-            ...ctx,
-            type: "typeorm:dataSource",
-            name: pascalCase(database),
-            typeormDataSource: ctx.features.find((value) => value.startsWith("typeorm:"))
-        });
+        return packageJson;
     }
-    addScripts() {
-        this.packageJson.addScripts({
-            typeorm: "typeorm-ts-node-commonjs"
-        });
-    }
-    addDependencies(ctx) {
-        this.packageJson.addDependencies({}, ctx);
+    $alterProjectFiles(project, data) {
+        if (data.typeorm) {
+            //set that in config.ts
+            project.serverSourceFile?.addImportDeclaration({
+                moduleSpecifier: "@tsed/typeorm"
+            });
+        }
+        return project;
     }
-    addDevDependencies(ctx) {
-        this.packageJson.addDevDependencies({}, ctx);
+    async $alterInitSubTasks(tasks, data) {
+        const database = getDatabase(data);
+        if (!database || !data.typeorm) {
+            return tasks;
+        }
+        const typeormDataSource = data.features?.find((value) => value.startsWith("typeorm:"));
+        return [
+            ...tasks,
+            ...(await this.cliService.getTasks("generate", {
+                ...data,
+                type: "typeorm:dataSource",
+                name: pascalCase(database),
+                typeormDataSource
+            }))
+        ];
     }
-};
-__decorate([
-    OnExec("init"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], TypeORMInitHook.prototype, "onExec", null);
-TypeORMInitHook = __decorate([
-    Injectable()
-], TypeORMInitHook);
-export { TypeORMInitHook };
+}
+injectable(TypeORMInitHook);

package/lib/esm/index.js

@@ -1,5 +1,5 @@
+import "./templates/datasource.template.js";
 import { CliPluginTypeORMModule } from "./CliPluginTypeORMModule.js";
 export * from "./hooks/TypeORMGenerateHook.js";
 export * from "./hooks/TypeORMInitHook.js";
-export * from "./utils/templateDir.js";
 export default CliPluginTypeORMModule;

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

@@ -0,0 +1,111 @@
+import { defineTemplate } from "@tsed/cli";
+import { getDatabase, getTypeORMDatabases } from "../utils/getTypeORMDatabases.js";
+import { camelCase } from "change-case";
+function datasourceConfig(database) {
+    switch (database) {
+        case "mysql":
+        case "mariadb":
+            return `
+  host: "localhost",
+  port: 3306,
+  username: "test",
+  password: "test",
+  database: "test"`;
+        case "sqlite":
+        case "better-sqlite3":
+            return `
+    database: "database.sqlite"`;
+        case "postgres":
+            return `
+    host: "localhost",
+    port: 5432,
+    username: "test",
+    password: "test",
+    database: "test"`;
+        case "cockroachdb":
+            return `
+    host: "localhost",
+    port: 26257,
+    username: "root",
+    password: "",
+    database: "defaultdb"`;
+        case "mssql":
+            return `
+    host: "localhost",
+    username: "sa",
+    password: "Admin12345",
+    database: "tempdb"`;
+        case "oracle":
+            return `
+    host: "localhost",
+    username: "system",
+    password: "oracle",
+    port: 1521,
+    sid: "xe.oracle.docker"`;
+        case "mongodb":
+            return `
+    database: "test"`;
+    }
+}
+export default defineTemplate({
+    id: "typeorm:datasource",
+    label: "TypeORM DataSource",
+    fileName: "{{symbolName}}.datasource",
+    outputDir: "{{srcDir}}/datasources",
+    prompts: () => {
+        const list = getTypeORMDatabases().map(([value, { name }]) => {
+            return {
+                name: name,
+                value: value
+            };
+        });
+        return [
+            {
+                type: "autocomplete",
+                name: "typeormDataSource",
+                message: "Which database type?",
+                when(state) {
+                    return state.type === "typeorm:datasource";
+                },
+                source: (state, keyword) => {
+                    if (keyword) {
+                        return list.filter((item) => item.name.toLowerCase().includes(keyword.toLowerCase()));
+                    }
+                    return list;
+                }
+            }
+        ];
+    },
+    render(symbolName, data) {
+        const database = getDatabase(data);
+        const instanceName = camelCase(symbolName);
+        return `import {injectable, logger} from "@tsed/di";
+import {DataSource} from "typeorm";
+import {Logger} from "@tsed/logger";
+
+export const ${instanceName} = new DataSource({
+  type: "${database}",
+  entities: [],
+  ${datasourceConfig(database)?.trim()}
+});
+
+export const ${symbolName} = injectable(Symbol.for("${symbolName}"))
+  .type("typeorm:datasource")
+  .asyncFactory(async () => {
+     await ${instanceName}.initialize();
+     
+     logger().info("Connected with typeorm to database: ${data.name}");
+
+     return ${instanceName};
+  })
+  .hooks({
+    $onDestroy(dataSource) {
+      return dataSource.isInitialized && dataSource.close();
+    }
+  })
+  .token();
+  
+export type ${symbolName} = DataSource;
+`;
+    }
+});

package/lib/esm/utils/getTypeORMDatabases.js

@@ -0,0 +1,7 @@
+import { FeaturesMap } from "@tsed/cli";
+export function getTypeORMDatabases() {
+    return Object.entries(FeaturesMap).filter(([value]) => value.startsWith("typeorm:"));
+}
+export function getDatabase(data) {
+    return data.typeormDataSource?.split(":").at(-1);
+}

package/lib/types/CliPluginTypeORMModule.d.ts

@@ -1,5 +1,6 @@
+import type { AlterPackageJson, RenderDataContext } from "@tsed/cli";
 import { ProjectPackageJson } from "@tsed/cli-core";
-export declare class CliPluginTypeORMModule {
+export declare class CliPluginTypeORMModule implements AlterPackageJson {
     protected packageJson: ProjectPackageJson;
-    install(): void;
+    $alterPackageJson(packageJson: ProjectPackageJson, data: RenderDataContext): ProjectPackageJson;
 }

package/lib/types/hooks/TypeORMGenerateHook.d.ts

@@ -1,29 +1,7 @@
-import { type GenerateCmdContext, ProvidersInfoService, SrcRendererService } from "@tsed/cli";
-import { CliDockerComposeYaml, ProjectPackageJson, type Tasks } from "@tsed/cli-core";
-export interface TypeORMGenerateOptions extends GenerateCmdContext {
-    typeormDataSource: string;
-    datasourceName: string;
-}
-export declare class TypeORMGenerateHook {
-    private providersInfoService;
+import { type AlterGenerateTasks, type GenerateCmdContext } from "@tsed/cli";
+import { CliDockerComposeYaml, ProjectPackageJson, type Task } from "@tsed/cli-core";
+export declare class TypeORMGenerateHook implements AlterGenerateTasks {
     protected projectPackageJson: ProjectPackageJson;
-    protected srcRenderService: SrcRendererService;
     protected cliDockerComposeYaml: CliDockerComposeYaml;
-    constructor(providersInfoService: ProvidersInfoService);
-    onGeneratePrompt(): {
-        type: string;
-        name: string;
-        message: string;
-        when(state: any): boolean;
-        source: (state: any, keyword: string) => {
-            name: string;
-            value: string;
-        }[];
-    }[];
-    onGenerateExec(ctx: TypeORMGenerateOptions): Tasks;
-    getTypeORMTypes(): [string, import("@tsed/cli").Feature][];
-    generateDataSourceTasks(ctx: TypeORMGenerateOptions): {
-        title: string;
-        task: () => Promise<void>;
-    }[];
+    $alterGenerateTasks(tasks: Task[], data: GenerateCmdContext): Task[] | Promise<Task[]>;
 }

package/lib/types/hooks/TypeORMInitHook.d.ts

@@ -1,10 +1,8 @@
-import type { InitCmdContext } from "@tsed/cli";
-import { CliService, ProjectPackageJson } from "@tsed/cli-core";
-export declare class TypeORMInitHook {
+import { type CliCommandHooks, ProjectClient, type RenderDataContext } from "@tsed/cli";
+import { CliService, ProjectPackageJson, type Task } from "@tsed/cli-core";
+export declare class TypeORMInitHook implements CliCommandHooks {
     protected cliService: CliService;
-    protected packageJson: ProjectPackageJson;
-    onExec(ctx: InitCmdContext): never[] | Promise<any[]>;
-    addScripts(): void;
-    addDependencies(ctx: InitCmdContext): void;
-    addDevDependencies(ctx: InitCmdContext): void;
+    $alterPackageJson(packageJson: ProjectPackageJson, data: RenderDataContext): ProjectPackageJson;
+    $alterProjectFiles(project: ProjectClient, data: RenderDataContext): ProjectClient;
+    $alterInitSubTasks(tasks: Task[], data: RenderDataContext): Promise<Task[]>;
 }

package/lib/types/index.d.ts

@@ -1,5 +1,5 @@
+import "./templates/datasource.template.js";
 import { CliPluginTypeORMModule } from "./CliPluginTypeORMModule.js";
 export * from "./hooks/TypeORMGenerateHook.js";
 export * from "./hooks/TypeORMInitHook.js";
-export * from "./utils/templateDir.js";
 export default CliPluginTypeORMModule;

package/lib/types/templates/datasource.template.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    namespace TsED {
+        interface GenerateOptions {
+            typeormDataSource?: string;
+            datasourceName?: string;
+        }
+    }
+}
+declare const _default: import("@tsed/cli").DefineTemplateOptions;
+export default _default;

package/lib/types/utils/getTypeORMDatabases.d.ts

@@ -0,0 +1,4 @@
+import { type GenerateCmdContext } from "@tsed/cli";
+import type { CliDatabases } from "@tsed/cli-core";
+export declare function getTypeORMDatabases(): [string, import("@tsed/cli").Feature][];
+export declare function getDatabase(data: GenerateCmdContext): CliDatabases | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tsed/cli-plugin-typeorm",
   "description": "Ts.ED CLI plugin. Add TypeORM support",
-  "version": "6.6.3",
+  "version": "7.0.0-alpha.1",
   "type": "module",
   "main": "./lib/esm/index.js",
   "source": "./src/index.ts",
@@ -26,9 +26,9 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/cli": "6.6.3",
-    "@tsed/cli-core": "6.6.3",
-    "@tsed/typescript": "6.6.3",
+    "@tsed/cli": "7.0.0-alpha.1",
+    "@tsed/cli-core": "7.0.0-alpha.1",
+    "@tsed/typescript": "7.0.0-alpha.1",
     "cross-env": "7.0.3",
     "typescript": "5.6.2",
     "vitest": "3.2.4"
@@ -40,5 +40,8 @@
   },
   "homepage": "https://github.com/tsedio/tsed-cli/tree/master/packages/cli-plugin-typeorm",
   "author": "Romain Lenzotti",
-  "license": "MIT"
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "alpha"
+  }
 }

package/lib/esm/utils/templateDir.js

@@ -1,2 +0,0 @@
-import { getTemplateDirectory } from "@tsed/cli-core";
-export const TEMPLATE_DIR = getTemplateDirectory(import.meta.dirname);

package/lib/types/utils/templateDir.d.ts

@@ -1 +0,0 @@
-export declare const TEMPLATE_DIR: string;

package/templates/datasource.hbs

@@ -1,81 +0,0 @@
-import {registerProvider} from "@tsed/di";
-import {DataSource} from "typeorm";
-import {Logger} from "@tsed/logger";
-
-export const {{symbolName}} = Symbol.for("{{symbolName}}");
-export type {{symbolName}} = DataSource;
-export const {{instanceName}} = new DataSource({
-  type: "{{database}}",
-  entities: [],
-{{#switch database}}
-  {{#case 'mysql'}}
-  host: "localhost",
-  port: 3306,
-  username: "test",
-  password: "test",
-  database: "test"
-  {{/case}}
-  {{#case 'mariadb'}}
-  host: "localhost",
-  port: 3306,
-  username: "test",
-  password: "test",
-  database: "test"
-  {{/case}}
-  {{#case 'sqlite'}}
-  database: "database.sqlite"
-  {{/case}}
-  {{#case 'better-sqlite3'}}
-  database: "database.sqlite"
-  {{/case}}
-  {{#case 'postgres'}}
-  host: "localhost",
-  port: 5432,
-  username: "test",
-  password: "test",
-  database: "test"
-  {{/case}}
-  {{#case 'cockroachdb'}}
-  host: "localhost",
-  port: 26257,
-  username: "root",
-  password: "",
-  database: "defaultdb"
-  {{/case}}
-  {{#case 'mssql'}}
-  host: "localhost",
-  username: "sa",
-  password: "Admin12345",
-  database: "tempdb"
-  {{/case}}
-  {{#case 'oracle'}}
-  host: "localhost",
-  username: "system",
-  password: "oracle",
-  port: 1521,
-  sid: "xe.oracle.docker"
-  {{/case}}
-  {{#case 'mongodb'}}
-  database: "test"
-  {{/case}}
-{{/switch}}
-});
-
-
-registerProvider<DataSource>({
-  provide: {{symbolName}},
-  type: "typeorm:datasource",
-  deps: [Logger],
-  async useAsyncFactory(logger: Logger) {
-    await {{instanceName}}.initialize();
-
-    logger.info("Connected with typeorm to database: {{name}}");
-
-    return {{instanceName}};
-  },
-  hooks: {
-    $onDestroy(dataSource) {
-      return dataSource.isInitialized && dataSource.close();
-    }
-  }
-});