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

package/lib/esm/CliPluginMongooseModule.js

@@ -1,4 +1,5 @@
 import { __decorate, __metadata } from "tslib";
+import "./templates/index.js";
 import { inject, Module, OnAdd, ProjectPackageJson } from "@tsed/cli-core";
 import { MongooseGenerateHook } from "./hooks/MongooseGenerateHook.js";
 import { MongooseInitHook } from "./hooks/MongooseInitHook.js";

package/lib/esm/hooks/MongooseGenerateHook.js

@@ -1,88 +1,28 @@
-var MongooseGenerateHook_1;
-import { __decorate, __metadata } from "tslib";
-import { ProvidersInfoService, SrcRendererService } from "@tsed/cli";
-import { CliDockerComposeYaml, inject, OnExec, ProjectPackageJson } from "@tsed/cli-core";
-import { Injectable } from "@tsed/di";
-import { camelCase, kebabCase } from "change-case";
-// @ts-ignore
-import { plural } from "pluralize";
+import { ProjectClient } from "@tsed/cli";
+import { CliDockerComposeYaml, inject, ProjectPackageJson } from "@tsed/cli-core";
+import { injectable } from "@tsed/di";
 import { CliMongoose } from "../services/CliMongoose.js";
-import { TEMPLATE_DIR } from "../utils/templateDir.js";
-let MongooseGenerateHook = MongooseGenerateHook_1 = class MongooseGenerateHook {
-    constructor(providersInfoService) {
-        this.providersInfoService = providersInfoService;
+export class MongooseGenerateHook {
+    constructor() {
         this.projectPackageJson = inject(ProjectPackageJson);
-        this.srcRenderService = inject(SrcRendererService);
         this.cliMongoose = inject(CliMongoose);
         this.cliDockerComposeYaml = inject(CliDockerComposeYaml);
-        providersInfoService
-            .add({
-            name: "Mongoose model",
-            value: "mongoose:model",
-            model: "{{symbolName}}.model",
-            baseDir: "models"
-        }, MongooseGenerateHook_1)
-            .add({
-            name: "Mongoose schema",
-            value: "mongoose:schema",
-            model: "{{symbolName}}.schema",
-            baseDir: "models"
-        }, MongooseGenerateHook_1)
-            .add({
-            name: "Mongoose connection",
-            value: "mongoose:connection"
-        }, MongooseGenerateHook_1);
     }
-    onGenerateExec(ctx) {
-        if (this.providersInfoService.isMyProvider(ctx.type, MongooseGenerateHook_1)) {
-            switch (ctx.type) {
-                case "mongoose:connection":
-                    return this.generateConnection(ctx);
-                case "mongoose:model":
-                case "mongoose:schema":
-                    return this.generateTemplate(ctx);
-            }
-        }
-        return [];
-    }
-    generateTemplate(ctx) {
-        const { symbolPath, type, symbolName } = ctx;
-        const template = `mongoose.${type.split(":")[1]}.hbs`;
-        const newCtx = {
-            ...ctx,
-            collectionName: plural(camelCase(symbolName.replace(/Schema|Model/gi, "")))
-        };
+    $alterGenerateTasks(tasks, data) {
         return [
-            {
-                title: `Generate ${ctx.type} file to '${symbolPath}.ts'`,
-                task: () => this.srcRenderService.render(template, newCtx, {
-                    output: `${symbolPath}.ts`,
-                    templateDir: TEMPLATE_DIR
-                })
-            }
-        ];
-    }
-    generateConnection(ctx) {
-        return [
-            {
-                title: `Generate Mongoose configuration file to '${kebabCase(ctx.name)}.config.ts'`,
-                task: () => this.cliMongoose.writeConfig(ctx.name, ctx)
-            },
+            ...tasks,
             {
                 title: "Generate docker-compose configuration",
-                task: () => this.cliDockerComposeYaml.addDatabaseService(ctx.name, "mongodb")
+                skip: (ctx) => ctx.type !== "mongoose.connection",
+                task: () => this.cliDockerComposeYaml.addDatabaseService(data.name, "mongodb")
             }
         ];
     }
-};
-__decorate([
-    OnExec("generate"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Array)
-], MongooseGenerateHook.prototype, "onGenerateExec", null);
-MongooseGenerateHook = MongooseGenerateHook_1 = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [ProvidersInfoService])
-], MongooseGenerateHook);
-export { MongooseGenerateHook };
+    $alterProjectFiles(project, data) {
+        if (data.commandName === "generate" && data.type === "mongoose.connection") {
+            this.cliMongoose.updateMongooseConfig(project, data.symbolName);
+        }
+        return project;
+    }
+}
+injectable(MongooseGenerateHook);

package/lib/esm/hooks/MongooseInitHook.js

@@ -1,47 +1,20 @@
-import { __decorate, __metadata } from "tslib";
-import { CliDockerComposeYaml, inject, OnExec, ProjectPackageJson } from "@tsed/cli-core";
-import { Injectable } from "@tsed/di";
+import { ProjectClient } from "@tsed/cli";
+import { inject, injectable } from "@tsed/di";
 import { CliMongoose } from "../services/CliMongoose.js";
-let MongooseInitHook = class MongooseInitHook {
+export class MongooseInitHook {
     constructor() {
         this.cliMongoose = inject(CliMongoose);
-        this.packageJson = inject(ProjectPackageJson);
-        this.cliDockerComposeYaml = inject(CliDockerComposeYaml);
     }
-    onExec(ctx) {
-        this.addScripts();
-        this.addDependencies(ctx);
-        this.addDevDependencies(ctx);
-        return [
-            {
-                title: "Generate Mongoose configuration",
-                task: () => this.cliMongoose.writeConfig("default", {
-                    symbolName: "MONGOOSE_DEFAULT"
-                })
-            },
-            {
-                title: "Generate docker-compose configuration",
-                task: () => this.cliDockerComposeYaml.addDatabaseService("mongodb", "mongodb")
-            }
-        ];
+    async $alterProjectFiles(project, data) {
+        if (data.commandName === "init" && data.mongoose) {
+            project.serverSourceFile?.addImportDeclaration({
+                moduleSpecifier: "@tsed/mongoose"
+            });
+            await project.dockerCompose.addDatabaseService("mongodb", "mongodb");
+            await this.cliMongoose.createMongooseConnection(project, "MONGOOSE_DEFAULT");
+            this.cliMongoose.updateConfigFile(project, data);
+        }
+        return project;
     }
-    addScripts() {
-        this.packageJson.addScripts({});
-    }
-    addDependencies(ctx) {
-        this.packageJson.addDependencies({}, ctx);
-    }
-    addDevDependencies(ctx) {
-        this.packageJson.addDevDependencies({}, ctx);
-    }
-};
-__decorate([
-    OnExec("init"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], MongooseInitHook.prototype, "onExec", null);
-MongooseInitHook = __decorate([
-    Injectable()
-], MongooseInitHook);
-export { MongooseInitHook };
+}
+injectable(MongooseInitHook);

package/lib/esm/index.js

@@ -2,5 +2,4 @@ import { CliPluginMongooseModule } from "./CliPluginMongooseModule.js";
 export * from "./hooks/MongooseGenerateHook.js";
 export * from "./hooks/MongooseInitHook.js";
 export * from "./services/CliMongoose.js";
-export * from "./utils/templateDir.js";
 export default CliPluginMongooseModule;

package/lib/esm/services/CliMongoose.js

@@ -1,45 +1,55 @@
-import { __decorate } from "tslib";
-import { basename, join } from "node:path";
-import { SrcRendererService } from "@tsed/cli";
-import { inject, Injectable, ProjectPackageJson } from "@tsed/cli-core";
-import { camelCase, constantCase, kebabCase } from "change-case";
-import { TEMPLATE_DIR } from "../utils/templateDir.js";
-let CliMongoose = class CliMongoose {
+import { ProjectClient, render } from "@tsed/cli";
+import { inject, injectable, ProjectPackageJson } from "@tsed/cli-core";
+import { camelCase } from "change-case";
+import { SyntaxKind } from "ts-morph";
+export class CliMongoose {
     constructor() {
         this.projectPackageJson = inject(ProjectPackageJson);
-        this.srcRenderer = inject(SrcRendererService);
     }
-    async writeConfig(name, options = {}) {
-        await this.srcRenderer.render("config.hbs", {
-            ...options,
-            symbolName: constantCase(name),
-            name: kebabCase(name)
-        }, {
-            output: `${kebabCase(name)}.config.ts`,
-            rootDir: join(this.srcRenderer.rootDir, "config", "mongoose"),
-            templateDir: TEMPLATE_DIR
+    async createMongooseConnection(project, name) {
+        const obj = await render("mongoose.connection", { name });
+        return this.updateMongooseConfig(project, obj.symbolName);
+    }
+    async updateMongooseConfig(project, name) {
+        const connectionSource = project.getSource(`{{srcDir}}/config/mongoose/${name}.ts`);
+        const { options, source } = await this.getMongooseConfig(project);
+        if (options && connectionSource) {
+            source.addImportDeclaration({
+                moduleSpecifier: `./${name}.js`,
+                defaultImport: camelCase(name)
+            });
+            options.addElement(camelCase(name));
+        }
+    }
+    async getMongooseConfig(project) {
+        let source = project.getSource("{{srcDir}}/config/mongoose/index.ts");
+        if (!source) {
+            source = (await render("mongoose.index", {
+                name: "index"
+            })).source;
+        }
+        // get default export options
+        const defaultExport = source.getStatement((statement) => {
+            return statement.isKind(SyntaxKind.ExportAssignment);
         });
-        return this.regenerateIndexConfig();
+        return { source, options: defaultExport?.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression) };
     }
-    async regenerateIndexConfig() {
-        const list = await this.srcRenderer.scan(["config/mongoose/*.config.ts"]);
-        const configs = list.map((file) => {
-            const name = basename(file).replace(/\.config\.ts/gi, "");
-            return {
-                name,
-                symbolName: camelCase(name)
-            };
+    updateConfigFile(project, data) {
+        const options = project.findConfiguration("config");
+        const configFile = project.configSourceFile;
+        if (!configFile || !options) {
+            return;
+        }
+        // set that in config.ts
+        configFile.addImportDeclaration({
+            moduleSpecifier: "./mongoose/index.js",
+            defaultImport: "mongooseConfig"
         });
-        return this.srcRenderer.render("index.hbs", {
-            configs
-        }, {
-            templateDir: TEMPLATE_DIR,
-            output: "index.ts",
-            rootDir: join(this.srcRenderer.rootDir, "config", "mongoose")
+        project.getPropertyAssignment(options, {
+            name: "mongoose",
+            kind: SyntaxKind.Identifier,
+            initializer: "mongooseConfig"
         });
     }
-};
-CliMongoose = __decorate([
-    Injectable()
-], CliMongoose);
-export { CliMongoose };
+}
+injectable(CliMongoose);

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

@@ -0,0 +1,15 @@
+import { constantCase, kebabCase } from "change-case";
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "mongoose.connection",
+    label: "Mongoose Connection",
+    fileName: "{{symbolName}}.connection",
+    outputDir: "{{srcDir}}/config/mongoose",
+    render(symbolName, data) {
+        return `export default {
+  id: "${symbolName}",
+  url: process.env.${constantCase(symbolName)}_URL || "mongodb://localhost:27017/${kebabCase(data.name)}",
+  connectionOptions: { }
+}`;
+    }
+});

package/lib/esm/templates/index.js

@@ -0,0 +1,4 @@
+import "./index.template";
+import "./connection.template";
+import "./mongooseModel.template";
+import "./mongooseSchema.template";

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

@@ -0,0 +1,12 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "mongoose.index",
+    label: "Mongoose Index",
+    fileName: "index",
+    outputDir: "{{srcDir}}/config/mongoose",
+    hidden: true,
+    render() {
+        return `//keep this default 
+export default [];`;
+    }
+});

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

@@ -0,0 +1,21 @@
+import { defineTemplate } from "@tsed/cli";
+import { camelCase } from "change-case";
+// @ts-ignore
+import { plural } from "pluralize";
+export default defineTemplate({
+    id: "mongoose.model",
+    label: "Mongoose model",
+    fileName: "{{symbolName}}.model",
+    outputDir: "{{srcDir}}/models",
+    render(symbolName) {
+        const collectionName = plural(camelCase(symbolName.replace(/Schema|Model/gi, "")));
+        return `import { Model, ObjectID } from "@tsed/mongoose";
+@Model({
+  name: "${collectionName}"
+})
+export class ${symbolName} {
+  @ObjectID("id")
+  _id: string;
+}`;
+    }
+});

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

@@ -0,0 +1,17 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "mongoose.schema",
+    label: "Mongoose schema",
+    fileName: "{{symbolName}}.schema",
+    outputDir: "{{srcDir}}/schemas",
+    render(symbolName) {
+        return `import { Property } from "@tsed/schema";
+import { Schema } from "@tsed/mongoose";
+
+@Schema()
+export class ${symbolName} {
+  @Property()
+  unique: string;
+}`;
+    }
+});

package/lib/types/CliPluginMongooseModule.d.ts

@@ -1,3 +1,4 @@
+import "./templates/index.js";
 import { ProjectPackageJson } from "@tsed/cli-core";
 export declare class CliPluginMongooseModule {
     protected packageJson: ProjectPackageJson;

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

@@ -1,15 +1,11 @@
-import { type GenerateCmdContext, ProvidersInfoService, SrcRendererService } from "@tsed/cli";
-import { CliDockerComposeYaml, ProjectPackageJson, type Tasks } from "@tsed/cli-core";
+import { type AlterGenerateTasks, type AlterProjectFiles, type GenerateCmdContext, ProjectClient } from "@tsed/cli";
+import { CliDockerComposeYaml, ProjectPackageJson, type Task } from "@tsed/cli-core";
 import { CliMongoose } from "../services/CliMongoose.js";
-export declare class MongooseGenerateHook {
-    private providersInfoService;
+export declare class MongooseGenerateHook implements AlterGenerateTasks, AlterProjectFiles {
     protected projectPackageJson: ProjectPackageJson;
-    protected srcRenderService: SrcRendererService;
     protected cliMongoose: CliMongoose;
     protected packages: any[];
     protected cliDockerComposeYaml: CliDockerComposeYaml;
-    constructor(providersInfoService: ProvidersInfoService);
-    onGenerateExec(ctx: GenerateCmdContext): Tasks;
-    private generateTemplate;
-    private generateConnection;
+    $alterGenerateTasks(tasks: Task[], data: GenerateCmdContext): Task[] | Promise<Task[]>;
+    $alterProjectFiles(project: ProjectClient, data: GenerateCmdContext): Promise<ProjectClient> | ProjectClient;
 }

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

@@ -1,15 +1,6 @@
-import type { InitCmdContext } from "@tsed/cli";
-import { CliDockerComposeYaml, ProjectPackageJson } from "@tsed/cli-core";
+import { type CliCommandHooks, ProjectClient, type RenderDataContext } from "@tsed/cli";
 import { CliMongoose } from "../services/CliMongoose.js";
-export declare class MongooseInitHook {
+export declare class MongooseInitHook implements CliCommandHooks {
     protected cliMongoose: CliMongoose;
-    protected packageJson: ProjectPackageJson;
-    protected cliDockerComposeYaml: CliDockerComposeYaml;
-    onExec(ctx: InitCmdContext): {
-        title: string;
-        task: () => Promise<void>;
-    }[];
-    addScripts(): void;
-    addDependencies(ctx: InitCmdContext): void;
-    addDevDependencies(ctx: InitCmdContext): void;
+    $alterProjectFiles(project: ProjectClient, data: RenderDataContext): Promise<ProjectClient>;
 }

package/lib/types/index.d.ts

@@ -2,5 +2,4 @@ import { CliPluginMongooseModule } from "./CliPluginMongooseModule.js";
 export * from "./hooks/MongooseGenerateHook.js";
 export * from "./hooks/MongooseInitHook.js";
 export * from "./services/CliMongoose.js";
-export * from "./utils/templateDir.js";
 export default CliPluginMongooseModule;

package/lib/types/services/CliMongoose.d.ts

@@ -1,8 +1,12 @@
-import { SrcRendererService } from "@tsed/cli";
+import { ProjectClient, type RenderDataContext } from "@tsed/cli";
 import { ProjectPackageJson } from "@tsed/cli-core";
 export declare class CliMongoose {
     protected projectPackageJson: ProjectPackageJson;
-    protected srcRenderer: SrcRendererService;
-    writeConfig(name: string, options?: any): Promise<void>;
-    regenerateIndexConfig(): Promise<void>;
+    createMongooseConnection(project: ProjectClient, name: string): Promise<void>;
+    updateMongooseConfig(project: ProjectClient, name: string): Promise<void>;
+    getMongooseConfig(project: ProjectClient): Promise<{
+        source: import("ts-morph").SourceFile;
+        options: import("ts-morph").ArrayLiteralExpression | undefined;
+    }>;
+    updateConfigFile(project: ProjectClient, data: RenderDataContext): void;
 }

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

@@ -0,0 +1,2 @@
+declare const _default: import("@tsed/cli").DefineTemplateOptions;
+export default _default;

package/lib/types/templates/index.d.ts

@@ -0,0 +1,4 @@
+import "./index.template";
+import "./connection.template";
+import "./mongooseModel.template";
+import "./mongooseSchema.template";

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

@@ -0,0 +1,2 @@
+declare const _default: import("@tsed/cli").DefineTemplateOptions;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: import("@tsed/cli").DefineTemplateOptions;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: import("@tsed/cli").DefineTemplateOptions;
+export default _default;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tsed/cli-plugin-mongoose",
   "description": "Ts.ED CLI plugin. Add Mongoose support",
-  "version": "6.6.3",
+  "version": "7.0.0-alpha.1",
   "type": "module",
   "main": "./lib/esm/index.js",
   "source": "./src/index.ts",
@@ -27,9 +27,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"
@@ -41,5 +41,8 @@
   },
   "homepage": "https://github.com/tsedio/tsed-cli/tree/master/packages/cli-plugin-mongoose",
   "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/config.hbs

@@ -1,5 +0,0 @@
-export default {
-  id: "{{name}}",
-  url: process.env.{{symbolName}}_URL || "mongodb://localhost:27017/{{name}}",
-  connectionOptions: { }
-};

package/templates/index.hbs

@@ -1,10 +0,0 @@
-// @tsed/cli do not edit
-{{#forEach configs}}
-import {{symbolName}}Config from "./{{name}}.config";
-{{/forEach}}
-
-export default [
-{{#forEach configs}}
-  {{symbolName}}Config{{#unless isLast}}, {{/unless}}
-{{/forEach}}
-];

package/templates/mongoose.model.hbs

@@ -1,22 +0,0 @@
-import { Model, ObjectID } from "@tsed/mongoose";
-/**
- * ## How to inject model?
- *
- * ```typescript
- * import type { MongooseModel } from "@tsed/mongoose";
- * import { Injectable, Inject } from "@tsed/di";
- *
- * @Injectable()
- * class MyService {
- *   @Inject({{ collectionName }})
- *   model: MongooseModel<{{ collectionName }}>;
- * }
- * ```
- */
-@Model({
-  name: "{{ collectionName }}"
-})
-export class {{symbolName}} {
-  @ObjectID("id")
-  _id: string;
-}

package/templates/mongoose.schema.hbs

@@ -1,8 +0,0 @@
-import { Property } from "@tsed/schema";
-import { Schema } from "@tsed/mongoose";
-
-@Schema()
-export class {{symbolName}} {
-  @Property()
-  unique: string;
-}