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

package/lib/esm/TypeGraphqlModule.js

@@ -1,6 +1,5 @@
 import { __decorate, __metadata } from "tslib";
 import { inject, Module, OnAdd, ProjectPackageJson } from "@tsed/cli-core";
-import { Inject } from "@tsed/di";
 import { TypeGraphqlInitHook } from "./hooks/TypeGraphqlInitHook.js";
 let TypeGraphqlModule = class TypeGraphqlModule {
     constructor() {

package/lib/esm/hooks/TypeGraphqlInitHook.js

@@ -1,39 +1,65 @@
-import { __decorate, __metadata } from "tslib";
-import { RootRendererService } from "@tsed/cli";
-import { inject, OnExec, ProjectPackageJson } from "@tsed/cli-core";
-import { Injectable } from "@tsed/di";
-import { TEMPLATE_DIR } from "../utils/templateDir.js";
-let TypeGraphqlInitHook = class TypeGraphqlInitHook {
-    constructor() {
-        this.packageJson = inject(ProjectPackageJson);
-        this.rootRenderer = inject(RootRendererService);
-    }
-    onExec(ctx) {
+import { exec, ProjectClient } from "@tsed/cli";
+import { createSubTasks } from "@tsed/cli-core";
+import { injectable } from "@tsed/di";
+import { SyntaxKind } from "ts-morph";
+export class TypeGraphqlInitHook {
+    async $alterInitSubTasks(tasks, data) {
         return [
+            ...tasks,
             {
-                title: "Generate files",
-                task: () => this.rootRenderer.renderAll([
-                    "/src/datasources/index.ts",
-                    "/src/datasources/MyDataSource.ts",
-                    "/src/resolvers/recipes/Recipe.ts",
-                    "/src/resolvers/recipes/RecipeNotFoundError.ts",
-                    "/src/resolvers/recipes/RecipeResolver.ts",
-                    "/src/resolvers/index.ts",
-                    "/src/services/RecipeService.ts"
-                ], ctx, {
-                    templateDir: `${TEMPLATE_DIR}/init`
-                })
+                title: "Generate initial resolver",
+                enabled: () => !!data.graphql,
+                task: createSubTasks(await exec("generate", {
+                    ...data,
+                    type: "typegraphql.resolver",
+                    name: "Recipe"
+                }), { ...data, concurrent: false })
             }
         ];
     }
-};
-__decorate([
-    OnExec("init"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], TypeGraphqlInitHook.prototype, "onExec", null);
-TypeGraphqlInitHook = __decorate([
-    Injectable()
-], TypeGraphqlInitHook);
-export { TypeGraphqlInitHook };
+    $alterProjectFiles(project, data) {
+        if (!data.graphql) {
+            return project;
+        }
+        if (data.commandName !== "init") {
+            return project;
+        }
+        if (project.serverSourceFile) {
+            project.serverSourceFile.addImportDeclaration({
+                moduleSpecifier: "@tsed/typegraphql"
+            });
+            project.serverSourceFile.addImportDeclaration({
+                moduleSpecifier: "./graphql/datasources/index.js"
+            });
+            project.serverSourceFile.addImportDeclaration({
+                moduleSpecifier: "./graphql/resolvers/index.js"
+            });
+        }
+        const options = project.findConfiguration("config");
+        if (!options) {
+            return project;
+        }
+        const graphql = project.getPropertyAssignment(options, {
+            name: "graphql",
+            kind: SyntaxKind.ObjectLiteralExpression,
+            initializer: "{}"
+        });
+        const defaultGraphql = project.getPropertyAssignment(graphql, {
+            name: "default",
+            kind: SyntaxKind.ObjectLiteralExpression,
+            initializer: "{}"
+        });
+        project.getPropertyAssignment(defaultGraphql, {
+            name: "path",
+            kind: SyntaxKind.StringLiteral,
+            initializer: '"/graphql"'
+        });
+        project.getPropertyAssignment(defaultGraphql, {
+            name: "buildSchemaOptions",
+            kind: SyntaxKind.ObjectLiteralExpression,
+            initializer: "{}"
+        });
+        return project;
+    }
+}
+injectable(TypeGraphqlInitHook);

package/lib/esm/index.js

@@ -1,4 +1,4 @@
+import "./templates/index.js";
 import { TypeGraphqlModule } from "./TypeGraphqlModule.js";
 export * from "./hooks/TypeGraphqlInitHook.js";
-export * from "./utils/templateDir.js";
 export default TypeGraphqlModule;

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

@@ -0,0 +1,27 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "typegraphql.datasource",
+    label: "TypeGraphQL DataSource",
+    fileName: "{{symbolName}}.datasource",
+    outputDir: "{{srcDir}}/graphql/datasources",
+    render(symbolName) {
+        return `import {DataSourceService} from "@tsed/typegraphql";
+import {RESTDataSource} from "apollo-datasource-rest";
+
+@DataSourceService()
+export class ${symbolName} extends RESTDataSource {
+  constructor() {
+    super();
+    this.baseURL = "http://localhost:8001";
+  }
+
+  willSendRequest(request: any) {
+    request.headers.set("Authorization", this.context.token);
+  }
+
+  getMyData(id: string) {
+    return this.get(\`/rest/calendars/\${id}\`);
+  }
+}`;
+    }
+});

package/lib/esm/templates/index.js

@@ -0,0 +1,4 @@
+import "./datasource.template.js";
+import "./resolver.template.js";
+import "./model.template.js";
+import "./service.template.js";

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

@@ -0,0 +1,21 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "typegraphql.model",
+    label: "TypeGraphQL Model",
+    fileName: "{{symbolName}}.model",
+    outputDir: "{{srcDir}}/graphql/models",
+    render(symbolName) {
+        return `import {Field, ID, ObjectType} from "type-graphql";
+
+@ObjectType({description: "Object representing cooking ${symbolName}"})
+export class ${symbolName} {
+  @Field((type) => ID)
+  id: string;
+
+  constructor(options: Partial<${symbolName}> = {}) {
+    options.id && (this.id = options.id);
+  }
+}
+`;
+    }
+});

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

@@ -0,0 +1,47 @@
+import { defineTemplate, render } from "@tsed/cli";
+// @ts-ignore
+import { plural } from "pluralize";
+import { camelCase, pascalCase } from "change-case";
+import { relative } from "path";
+import { dirname } from "node:path";
+export default defineTemplate({
+    id: "typegraphql.resolver",
+    label: "TypeGraphQL Resolver",
+    fileName: "{{symbolName}}.resolver",
+    outputDir: "{{srcDir}}/graphql/resolvers",
+    async render(symbolName, data) {
+        const modelInfo = await render("typegraphql.model", {
+            name: data.name
+        });
+        const serviceInfo = await render("typegraphql.service", {
+            name: data.name
+        });
+        const name = pascalCase(data.name);
+        const modelName = modelInfo?.symbolName;
+        const serviceName = serviceInfo?.symbolName;
+        const listName = camelCase(plural(name));
+        const getName = camelCase(name);
+        const relativeModelPath = relative(dirname(data.symbolPath), String(modelInfo?.symbolPath));
+        const relativeServicePath = relative(dirname(data.symbolPath), String(serviceInfo?.symbolPath));
+        return `import {ResolverService} from "@tsed/typegraphql";
+import {Arg, Query} from "type-graphql";
+import {${modelName}} from "${relativeModelPath}.js";
+import {${serviceName}} from "${relativeServicePath}.js";
+
+@ResolverService(${modelName})
+export class ${symbolName} {
+  protected service = inject(${serviceName});
+  
+  @Query((returns) => ${modelName})
+  async ${getName}(@Arg("id") id: string) {
+    return this.service.getById(id);
+  }
+  
+  @Query((returns) => [${modelName}], {description: "Get all items"})
+  ${listName}(): Promise<${modelName}[]> {
+    return this.service.findAll({});
+  }
+}
+`;
+    }
+});

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

@@ -0,0 +1,23 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "typegraphql.service",
+    label: "TypeGraphQL Service",
+    fileName: "{{symbolName}}.service",
+    outputDir: "{{srcDir}}/services",
+    hidden: true,
+    render(symbolName) {
+        return `import {Injectable} from "@tsed/di";
+
+@Injectable()
+export class ${symbolName} {
+  getById(id: string) {
+    return null;
+  }
+  
+  findAll(query: any) {
+    return [];
+  }
+}
+`;
+    }
+});