@forgerapi/codegen 0.0.1

package/dist/generators/forger-module/forger-module.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateForgerModule = generateForgerModule;
+const utils_1 = require("../../utils");
+function generateForgerModule(mod, options) {
+    const kebab = (0, utils_1.toKebab)(mod.name);
+    const mBase = options?.modelRelativeBase ?? "..";
+    const aBase = options?.actionBase ?? ".";
+    const iBase = options?.implBase ?? ".";
+    const lines = [];
+    lines.push(`import { Module } from "@nestjs/common";`);
+    lines.push("");
+    const imports = [];
+    const moduleImports = [];
+    for (const modelName of mod.models) {
+        const mk = (0, utils_1.toKebab)(modelName);
+        imports.push(`import { ${modelName}Module } from "${mBase}/${mk}/${mk}.module";`);
+        moduleImports.push(`${modelName}Module`);
+    }
+    for (const action of mod.actions) {
+        const ak = (0, utils_1.toKebab)(action.name);
+        imports.push(`import { ${action.name}ActionAbstractService } from "${aBase}/${ak}/${ak}.action-service";`);
+        imports.push(`import { ${action.name}ActionController } from "${aBase}/${ak}/${ak}.action-controller";`);
+        imports.push(`import { ${action.name}ActionImplService } from "${iBase}/${ak}.action-impl";`);
+    }
+    for (const imp of imports) {
+        lines.push(imp);
+    }
+    lines.push("");
+    const controllerNames = mod.actions.map((a) => `${a.name}ActionController`);
+    const providerEntries = mod.actions.map((a) => `    { provide: ${a.name}ActionAbstractService, useClass: ${a.name}ActionImplService },`);
+    lines.push(`@Module({`);
+    if (moduleImports.length > 0) {
+        lines.push(`  imports: [${moduleImports.join(", ")}],`);
+    }
+    if (controllerNames.length > 0) {
+        lines.push(`  controllers: [${controllerNames.join(", ")}],`);
+    }
+    if (providerEntries.length > 0) {
+        lines.push(`  providers: [`);
+        for (const entry of providerEntries) {
+            lines.push(entry);
+        }
+        lines.push(`  ],`);
+    }
+    lines.push("})");
+    lines.push(`export class ${mod.name}Module {}`);
+    return lines.join("\n");
+}

package/dist/generators/forger-module/index.d.ts

@@ -0,0 +1 @@
+export { generateForgerModule } from "./forger-module";

package/dist/generators/forger-module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateForgerModule = void 0;
+var forger_module_1 = require("./forger-module");
+Object.defineProperty(exports, "generateForgerModule", { enumerable: true, get: function () { return forger_module_1.generateForgerModule; } });

package/dist/generators/forger-modules.d.ts

@@ -0,0 +1,2 @@
+import type { ForgerAction, ForgerModel, ForgerModule } from "@forgerapi/ast";
+export declare function generateForgerModules(models: ForgerModel[], actions: ForgerAction[], modules: ForgerModule[]): string;

package/dist/generators/forger-modules.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateForgerModules = generateForgerModules;
+const utils_1 = require("../utils");
+function generateForgerModules(models, actions, modules) {
+    const lines = [];
+    lines.push(`import { Module } from "@nestjs/common";`);
+    lines.push("");
+    const imports = [
+        `import { PrismaModule } from "./common/prisma/prisma.module";`,
+    ];
+    for (const model of models) {
+        const kebab = (0, utils_1.toKebab)(model.name);
+        imports.push(`import { ${model.name}Module } from "./${kebab}/${kebab}.module";`);
+    }
+    for (const action of actions) {
+        const kebab = (0, utils_1.toKebab)(action.name);
+        imports.push(`import { ${action.name}ActionModule } from "./${kebab}/${kebab}.action-module";`);
+    }
+    for (const mod of modules) {
+        const kebab = (0, utils_1.toKebab)(mod.name);
+        imports.push(`import { ${mod.name}Module } from "./${kebab}/${kebab}.module";`);
+    }
+    for (const imp of imports) {
+        lines.push(imp);
+    }
+    lines.push("");
+    const moduleNames = [
+        "PrismaModule",
+        ...models.map((m) => `${m.name}Module`),
+        ...actions.map((a) => `${a.name}ActionModule`),
+        ...modules.map((m) => `${m.name}Module`),
+    ];
+    lines.push(`@Module({`);
+    lines.push(`  imports: [${moduleNames.join(", ")}],`);
+    lines.push(`  exports: [${moduleNames.join(", ")}],`);
+    lines.push("})");
+    lines.push("export class ForgerModulesModule {}");
+    return lines.join("\n");
+}

package/dist/generators/guard/guard.d.ts

@@ -0,0 +1,2 @@
+import type { ForgerGuard } from "@forgerapi/ast";
+export declare function generateGuardStub(guard: ForgerGuard): string;

package/dist/generators/guard/guard.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGuardStub = generateGuardStub;
+function generateGuardStub(guard) {
+    const lines = [];
+    lines.push(`import { Injectable, CanActivate, ExecutionContext } from "@nestjs/common";`);
+    lines.push("");
+    lines.push("@Injectable()");
+    lines.push(`export class ${guard.name} implements CanActivate {`);
+    lines.push("  canActivate(context: ExecutionContext): boolean | Promise<boolean> {");
+    lines.push("    return true;");
+    lines.push("  }");
+    lines.push("}");
+    return lines.join("\n");
+}

package/dist/generators/guard/index.d.ts

@@ -0,0 +1 @@
+export { generateGuardStub } from "./guard";

package/dist/generators/guard/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGuardStub = void 0;
+var guard_1 = require("./guard");
+Object.defineProperty(exports, "generateGuardStub", { enumerable: true, get: function () { return guard_1.generateGuardStub; } });

package/dist/generators/module/index.d.ts

@@ -0,0 +1 @@
+export { generateModuleModule } from "./module-module";

package/dist/generators/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModuleModule = void 0;
+var module_module_1 = require("./module-module");
+Object.defineProperty(exports, "generateModuleModule", { enumerable: true, get: function () { return module_module_1.generateModuleModule; } });

package/dist/generators/module/module-module.d.ts

@@ -0,0 +1,2 @@
+import type { ForgerModule } from "@forgerapi/ast";
+export declare function generateModuleModule(mod: ForgerModule): string;

package/dist/generators/module/module-module.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModuleModule = generateModuleModule;
+const utils_1 = require("../../utils");
+function generateModuleModule(mod) {
+    const kebab = (0, utils_1.toKebab)(mod.name);
+    const lines = [];
+    lines.push(`import { Module } from "@nestjs/common";`);
+    lines.push("");
+    const imports = [];
+    const moduleImports = [];
+    for (const modelName of mod.models) {
+        const mk = (0, utils_1.toKebab)(modelName);
+        imports.push(`import { ${modelName}Module } from "../${mk}/${mk}.module";`);
+        moduleImports.push(`${modelName}Module`);
+    }
+    for (const action of mod.actions) {
+        const ak = (0, utils_1.toKebab)(action.name);
+        imports.push(`import { ${action.name}ActionAbstractService } from "./${ak}.action-service";`);
+        imports.push(`import { ${action.name}ActionController } from "./${ak}.action-controller";`);
+        imports.push(`import { ${action.name}ActionImplService } from "./${ak}.action-impl";`);
+    }
+    for (const imp of imports) {
+        lines.push(imp);
+    }
+    lines.push("");
+    const controllerNames = mod.actions.map((a) => `${a.name}ActionController`);
+    const providerEntries = mod.actions.map((a) => `    { provide: ${a.name}ActionAbstractService, useClass: ${a.name}ActionImplService },`);
+    lines.push(`@Module({`);
+    if (moduleImports.length > 0) {
+        lines.push(`  imports: [${moduleImports.join(", ")}],`);
+    }
+    if (controllerNames.length > 0) {
+        lines.push(`  controllers: [${controllerNames.join(", ")}],`);
+    }
+    if (providerEntries.length > 0) {
+        lines.push(`  providers: [`);
+        for (const entry of providerEntries) {
+            lines.push(entry);
+        }
+        lines.push(`  ],`);
+    }
+    lines.push("})");
+    lines.push(`export class ${mod.name}Module {}`);
+    return lines.join("\n");
+}

package/dist/generators/module.d.ts

@@ -0,0 +1,4 @@
+import type { ForgerModel } from "@forgerapi/ast";
+export declare function generateModule(model: ForgerModel, options?: {
+    implRelative?: string;
+}): string;

package/dist/generators/module.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModule = generateModule;
+const utils_1 = require("../utils");
+function generateModule(model, options) {
+    const kebab = (0, utils_1.toKebab)(model.name);
+    const iRel = options?.implRelative ?? `./${kebab}.impl`;
+    const lines = [];
+    lines.push(`import { Module } from "@nestjs/common";`);
+    lines.push(`import { ${model.name}AbstractService } from "./${kebab}.service";`);
+    lines.push(`import { ${model.name}Controller } from "./${kebab}.controller";`);
+    lines.push(`import { ${model.name}ImplService } from "${iRel}";`);
+    lines.push("");
+    lines.push(`@Module({`);
+    lines.push(`  controllers: [${model.name}Controller],`);
+    lines.push("  providers: [");
+    lines.push("    {");
+    lines.push(`      provide: ${model.name}AbstractService,`);
+    lines.push(`      useClass: ${model.name}ImplService,`);
+    lines.push("    },");
+    lines.push("  ],");
+    lines.push("})");
+    lines.push(`export class ${model.name}Module {}`);
+    return lines.join("\n");
+}

package/dist/generators/prisma-module.d.ts

@@ -0,0 +1 @@
+export declare function generatePrismaModule(): string;

package/dist/generators/prisma-module.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrismaModule = generatePrismaModule;
+function generatePrismaModule() {
+    return `import { Global, Module } from "@nestjs/common";
+import { PrismaService } from "./prisma.service";
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}
+`;
+}

package/dist/generators/prisma-service.d.ts

@@ -0,0 +1 @@
+export declare function generatePrismaService(): string;

package/dist/generators/prisma-service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrismaService = generatePrismaService;
+function generatePrismaService() {
+    return `import { Injectable, OnModuleInit, OnModuleDestroy } from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+
+@Injectable()
+export class PrismaService
+	extends PrismaClient
+	implements OnModuleInit, OnModuleDestroy
+{
+	async onModuleInit() {
+		await this.$connect();
+	}
+
+	async onModuleDestroy() {
+		await this.$disconnect();
+	}
+}
+`;
+}

package/dist/generators/prisma.d.ts

@@ -0,0 +1,2 @@
+import type { ForgerSchema } from "@forgerapi/ast";
+export declare function generatePrismaSchema(schema: ForgerSchema): string;

package/dist/generators/prisma.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrismaSchema = generatePrismaSchema;
+function generatePrismaSchema(schema) {
+    const lines = [];
+    lines.push("datasource db {");
+    lines.push('  provider = "postgresql"');
+    lines.push('  url      = env("DATABASE_URL")');
+    lines.push("}");
+    lines.push("");
+    lines.push("generator client {");
+    lines.push('  provider = "prisma-client-js"');
+    lines.push("}");
+    lines.push("");
+    for (const enm of schema.enums) {
+        lines.push(`enum ${enm.name} {`);
+        for (const value of enm.values) {
+            lines.push(`  ${value}`);
+        }
+        lines.push("}");
+        lines.push("");
+    }
+    for (const model of schema.models) {
+        lines.push(`model ${model.name} {`);
+        for (const field of model.fields) {
+            if (field.relation && field.relation.isArray)
+                continue;
+            const prismaType = toPrismaType(field, schema);
+            const annotations = renderAnnotations(field, schema);
+            lines.push(`  ${field.name} ${prismaType}${annotations}`);
+        }
+        for (const field of model.fields) {
+            if (field.relation && field.relation.isArray) {
+                lines.push(`  ${field.name} ${field.relation.target}[]`);
+            }
+        }
+        lines.push("}");
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function toPrismaType(field, schema) {
+    if (field.relation && !field.relation.isArray) {
+        return field.relation.target;
+    }
+    const isEnum = schema.enums.some((e) => e.name === field.type);
+    if (isEnum) {
+        return field.type;
+    }
+    switch (field.type) {
+        case "string":
+            return "String";
+        case "number":
+            return "Int";
+        case "boolean":
+            return "Boolean";
+        case "uuid":
+            return "String";
+        case "datetime":
+            return "DateTime";
+        default:
+            return "String";
+    }
+}
+function renderAnnotations(field, schema) {
+    const parts = [];
+    let isId = false;
+    for (const c of field.constraints) {
+        if (c.type === "id") {
+            parts.push("@id");
+            isId = true;
+        }
+        if (c.type === "unique") {
+            parts.push("@unique");
+        }
+        if (c.type === "default") {
+            if (c.value === "uuid") {
+                parts.push("@default(uuid())");
+            }
+            else if (c.value === "now") {
+                parts.push("@default(now())");
+            }
+            else {
+                const isEnum = schema.enums.some((e) => e.values.includes(c.value));
+                if (isEnum) {
+                    parts.push(`@default(${c.value})`);
+                }
+                else {
+                    parts.push(`@default(${c.value})`);
+                }
+            }
+        }
+    }
+    if (!isId && field.type === "uuid" && !field.relation) {
+        parts.push("@default(uuid())");
+    }
+    if (field.relation && !field.relation.isArray && field.relation.field) {
+        parts.push(`@relation(fields: [${field.relation.field}], references: [id])`);
+    }
+    return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}

package/dist/generators/service.d.ts

@@ -0,0 +1,8 @@
+import type { ForgerModel } from "@forgerapi/ast";
+export declare function generateAbstractService(model: ForgerModel): string;
+export declare function generateModelImpl(model: ForgerModel, options?: {
+    serviceRelative?: string;
+    createDtoRelative?: string;
+    updateDtoRelative?: string;
+    prismaRelative?: string;
+}): string;

package/dist/generators/service.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAbstractService = generateAbstractService;
+exports.generateModelImpl = generateModelImpl;
+const utils_1 = require("../utils");
+function generateAbstractService(model) {
+    const kebab = (0, utils_1.toKebab)(model.name);
+    const lines = [];
+    lines.push(`import { Create${model.name}Dto } from "./dto/create-${kebab}.dto";`);
+    lines.push(`import { Update${model.name}Dto } from "./dto/update-${kebab}.dto";`);
+    lines.push("");
+    lines.push(`export abstract class ${model.name}AbstractService {`);
+    lines.push("");
+    lines.push(`  abstract create(dto: Create${model.name}Dto): Promise<any>;`);
+    lines.push("");
+    lines.push("  abstract findAll(): Promise<any>;");
+    lines.push("");
+    lines.push("  abstract findOne(id: string): Promise<any>;");
+    lines.push("");
+    lines.push(`  abstract update(id: string, dto: Update${model.name}Dto): Promise<any>;`);
+    lines.push("");
+    lines.push("  abstract remove(id: string): Promise<any>;");
+    lines.push("");
+    lines.push("}");
+    return lines.join("\n");
+}
+function generateModelImpl(model, options) {
+    const kebab = (0, utils_1.toKebab)(model.name);
+    const sRel = options?.serviceRelative ?? `./${kebab}.service`;
+    const cRel = options?.createDtoRelative ?? `./dto/create-${kebab}.dto`;
+    const uRel = options?.updateDtoRelative ?? `./dto/update-${kebab}.dto`;
+    const pRel = options?.prismaRelative ?? "../common/prisma/prisma.service";
+    const lines = [];
+    lines.push(`import { Injectable } from "@nestjs/common";`);
+    lines.push(`import { PrismaService } from "${pRel}";`);
+    lines.push(`import { ${model.name}AbstractService } from "${sRel}";`);
+    lines.push(`import { Create${model.name}Dto } from "${cRel}";`);
+    lines.push(`import { Update${model.name}Dto } from "${uRel}";`);
+    lines.push("");
+    lines.push("@Injectable()");
+    lines.push(`export class ${model.name}ImplService extends ${model.name}AbstractService {`);
+    lines.push("  constructor(private readonly prisma: PrismaService) {");
+    lines.push("    super();");
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  async create(dto: Create${model.name}Dto): Promise<any> {`);
+    lines.push(`    return this.prisma.${lowerFirst(model.name)}.create({ data: dto });`);
+    lines.push("  }");
+    lines.push("");
+    lines.push("  async findAll(): Promise<any> {");
+    lines.push(`    return this.prisma.${lowerFirst(model.name)}.findMany();`);
+    lines.push("  }");
+    lines.push("");
+    lines.push("  async findOne(id: string): Promise<any> {");
+    lines.push(`    return this.prisma.${lowerFirst(model.name)}.findUnique({ where: { id } });`);
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  async update(id: string, dto: Update${model.name}Dto): Promise<any> {`);
+    lines.push(`    return this.prisma.${lowerFirst(model.name)}.update({ where: { id }, data: dto });`);
+    lines.push("  }");
+    lines.push("");
+    lines.push("  async remove(id: string): Promise<any> {");
+    lines.push(`    return this.prisma.${lowerFirst(model.name)}.delete({ where: { id } });`);
+    lines.push("  }");
+    lines.push("");
+    lines.push("}");
+    return lines.join("\n");
+}
+function lowerFirst(s) {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { ForgerSchema } from "@forgerapi/ast";
+import { generateController } from "./generators/controller";
+import { generateCreateDto, generateResponseDto, generateUpdateDto, type SwaggerConfig } from "./generators/dto";
+import { generateEnum } from "./generators/enum";
+import { generateModule } from "./generators/module";
+import { generatePrismaSchema } from "./generators/prisma";
+import { generatePrismaModule } from "./generators/prisma-module";
+import { generatePrismaService } from "./generators/prisma-service";
+import { generateAbstractService, generateModelImpl } from "./generators/service";
+import { generateForgerModules } from "./generators/forger-modules";
+export type { SwaggerConfig };
+export { generateAbstractService, generateController, generateCreateDto, generateEnum, generateForgerModules, generateModelImpl, generateModule, generatePrismaModule, generatePrismaSchema, generatePrismaService, generateResponseDto, generateUpdateDto, };
+export interface ForgerConfig {
+    outDir: string;
+    prismaSchema: string;
+    swagger?: boolean;
+    deleteOrphans?: boolean;
+}
+export declare function generate(schema: ForgerSchema, config: ForgerConfig): Promise<string[]>;
+export declare function runForger(config: ForgerConfig): Promise<string[]>;
+export declare function watchForger(config: ForgerConfig): void;