@forgerapi/codegen 0.0.1

package/dist/codemod.d.ts

@@ -0,0 +1,3 @@
+import type { RenameInfo } from "./schema-cache";
+export declare function applyCodemod(outDir: string, renames: RenameInfo[]): string[];
+export declare function registerForgerModules(outDir: string, hasModules: boolean): string | null;

package/dist/codemod.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodemod = applyCodemod;
+exports.registerForgerModules = registerForgerModules;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const ts_morph_1 = require("ts-morph");
+const utils_1 = require("./utils");
+function applyCodemod(outDir, renames) {
+    const logs = [];
+    const project = new ts_morph_1.Project();
+    for (const r of renames) {
+        if (r.type === "model") {
+            const log = renameModelImpl(outDir, r.oldName, r.newName, project);
+            if (log)
+                logs.push(log);
+            const oldDir = (0, node_path_1.resolve)(outDir, (0, utils_1.toKebab)(r.oldName));
+            if ((0, node_fs_1.existsSync)(oldDir)) {
+                (0, node_fs_1.rmSync)(oldDir, { recursive: true, force: true });
+                logs.push(`  removed old model directory: ${oldDir}`);
+            }
+        }
+        else if (r.type === "action") {
+            const log = renameActionImpl(outDir, r.oldName, r.newName, project);
+            if (log)
+                logs.push(log);
+            const oldDir = (0, node_path_1.resolve)(outDir, (0, utils_1.toKebab)(r.oldName));
+            if ((0, node_fs_1.existsSync)(oldDir)) {
+                (0, node_fs_1.rmSync)(oldDir, { recursive: true, force: true });
+                logs.push(`  removed old action directory: ${oldDir}`);
+            }
+        }
+    }
+    return logs;
+}
+function renameModelImpl(outDir, oldName, newName, project) {
+    const oldKebab = (0, utils_1.toKebab)(oldName);
+    const newKebab = (0, utils_1.toKebab)(newName);
+    const oldPath = (0, node_path_1.resolve)(outDir, oldKebab, "impl", `${oldKebab}.impl.ts`);
+    const newDir = (0, node_path_1.resolve)(outDir, newKebab, "impl");
+    const newPath = (0, node_path_1.resolve)(newDir, `${newKebab}.impl.ts`);
+    if (!(0, node_fs_1.existsSync)(oldPath))
+        return null;
+    (0, node_fs_1.mkdirSync)(newDir, { recursive: true });
+    const sourceFile = project.addSourceFileAtPath(oldPath);
+    const classes = sourceFile.getClasses();
+    for (const cls of classes) {
+        const oldClassName = `${oldName}ImplService`;
+        const newClassName = `${newName}ImplService`;
+        if (cls.getName() === oldClassName) {
+            cls.rename(newClassName);
+        }
+        const extendsDec = cls.getExtends();
+        if (extendsDec) {
+            const oldExtends = `${oldName}AbstractService`;
+            const newExtends = `${newName}AbstractService`;
+            if (extendsDec.getText() === oldExtends) {
+                extendsDec.replaceWithText(newExtends);
+            }
+        }
+    }
+    const importDecls = sourceFile.getImportDeclarations();
+    for (const imp of importDecls) {
+        const moduleSpecifier = imp.getModuleSpecifierValue();
+        if (moduleSpecifier.includes(oldKebab)) {
+            imp.setModuleSpecifier(moduleSpecifier.replace(oldKebab, newKebab));
+        }
+    }
+    sourceFile.move(newPath);
+    sourceFile.saveSync();
+    (0, node_fs_1.unlinkSync)(oldPath);
+    return `  renamed model impl: ${oldName} → ${newName}`;
+}
+function registerForgerModules(outDir, hasModules) {
+    const appModulePath = (0, node_path_1.resolve)(outDir, "app.module.ts");
+    if (!(0, node_fs_1.existsSync)(appModulePath))
+        return null;
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.addSourceFileAtPath(appModulePath);
+    const existingImport = sourceFile.getImportDeclaration((dec) => dec.getModuleSpecifierValue() === "./forger-modules.module");
+    if (hasModules) {
+        if (existingImport)
+            return null;
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "./forger-modules.module",
+            namedImports: ["ForgerModulesModule"],
+        });
+        const classDec = sourceFile.getClasses()[0];
+        if (!classDec)
+            return null;
+        const moduleDecorator = classDec.getDecorator("Module");
+        if (!moduleDecorator)
+            return null;
+        const arg = moduleDecorator.getArguments()[0];
+        if (!arg)
+            return null;
+        const properties = arg.getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+        const importsProp = properties.find((p) => p.getName() === "imports");
+        if (importsProp) {
+            const initializer = importsProp.getInitializer();
+            if (initializer?.getKind() === ts_morph_1.SyntaxKind.ArrayLiteralExpression) {
+                const arr = initializer.asKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                const existingElements = arr
+                    .getElements()
+                    .map((e) => e.getText());
+                if (!existingElements.includes("ForgerModulesModule")) {
+                    arr.addElement("ForgerModulesModule");
+                }
+            }
+        }
+        sourceFile.saveSync();
+        return `  registered ForgerModulesModule in AppModule`;
+    }
+    else {
+        if (!existingImport)
+            return null;
+        existingImport.remove();
+        const classDec = sourceFile.getClasses()[0];
+        if (!classDec)
+            return null;
+        const moduleDecorator = classDec.getDecorator("Module");
+        if (!moduleDecorator)
+            return null;
+        const arg = moduleDecorator.getArguments()[0];
+        if (!arg)
+            return null;
+        const properties = arg.getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+        const importsProp = properties.find((p) => p.getName() === "imports");
+        if (importsProp) {
+            const initializer = importsProp.getInitializer();
+            if (initializer?.getKind() === ts_morph_1.SyntaxKind.ArrayLiteralExpression) {
+                const arr = initializer.asKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+                const elements = arr.getElements();
+                const idx = elements.findIndex((e) => e.getText() === "ForgerModulesModule");
+                if (idx !== -1) {
+                    arr.removeElement(idx);
+                }
+            }
+        }
+        sourceFile.saveSync();
+        return `  removed ForgerModulesModule from AppModule (no models/actions)`;
+    }
+}
+function renameActionImpl(outDir, oldName, newName, project) {
+    const oldKebab = (0, utils_1.toKebab)(oldName);
+    const newKebab = (0, utils_1.toKebab)(newName);
+    const oldPath = (0, node_path_1.resolve)(outDir, oldKebab, "impl", `${oldKebab}.action-impl.ts`);
+    const newDir = (0, node_path_1.resolve)(outDir, newKebab, "impl");
+    const newPath = (0, node_path_1.resolve)(newDir, `${newKebab}.action-impl.ts`);
+    if (!(0, node_fs_1.existsSync)(oldPath))
+        return null;
+    (0, node_fs_1.mkdirSync)(newDir, { recursive: true });
+    const sourceFile = project.addSourceFileAtPath(oldPath);
+    const classes = sourceFile.getClasses();
+    for (const cls of classes) {
+        const oldClassName = `${oldName}ActionImplService`;
+        const newClassName = `${newName}ActionImplService`;
+        if (cls.getName() === oldClassName) {
+            cls.rename(newClassName);
+        }
+        const extendsDec = cls.getExtends();
+        if (extendsDec) {
+            const oldExtends = `${oldName}ActionAbstractService`;
+            const newExtends = `${newName}ActionAbstractService`;
+            if (extendsDec.getText() === oldExtends) {
+                extendsDec.replaceWithText(newExtends);
+            }
+        }
+    }
+    const importDecls = sourceFile.getImportDeclarations();
+    for (const imp of importDecls) {
+        const moduleSpecifier = imp.getModuleSpecifierValue();
+        if (moduleSpecifier.includes(oldKebab)) {
+            imp.setModuleSpecifier(moduleSpecifier.replace(oldKebab, newKebab));
+        }
+    }
+    sourceFile.move(newPath);
+    sourceFile.saveSync();
+    (0, node_fs_1.unlinkSync)(oldPath);
+    return `  renamed action impl: ${oldName} → ${newName}`;
+}

package/dist/generators/action/controller.d.ts

@@ -0,0 +1,5 @@
+import type { ForgerAction, ForgerGuard } from "@forgerapi/ast";
+export declare function generateActionController(action: ForgerAction, options?: {
+    routePrefix?: string;
+    guards?: ForgerGuard[];
+}): string;

package/dist/generators/action/controller.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionController = generateActionController;
+const utils_1 = require("../../utils");
+function generateActionController(action, options) {
+    const kebab = (0, utils_1.toKebab)(action.name);
+    const lines = [];
+    lines.push(`import { Controller, Post, Body } from "@nestjs/common";`);
+    lines.push(`import { ApiTags, ApiOperation } from "@nestjs/swagger";`);
+    lines.push(`import { ${action.name}ActionAbstractService } from "./${kebab}.action-service";`);
+    lines.push(`import { ${action.name}ActionDto } from "./${kebab}.action-dto";`);
+    if (options?.guards && options.guards.length > 0) {
+        for (const guard of options.guards) {
+            if (guard.import) {
+                lines.push(`import { ${guard.name} } from "${guard.import}";`);
+            }
+            lines.push(`import { UseGuards } from "@nestjs/common";`);
+        }
+    }
+    lines.push("");
+    const apiTag = options?.routePrefix
+        ? `"${options.routePrefix}"`
+        : '"actions"';
+    const controllerRoute = options?.routePrefix || "actions";
+    const actionRoute = action.route || kebab;
+    const mergedRoute = options?.routePrefix && action.route
+        ? action.route
+        : actionRoute;
+    lines.push(`@ApiTags(${apiTag})`);
+    if (options?.routePrefix) {
+        lines.push(`@Controller("${options.routePrefix}")`);
+    }
+    else {
+        lines.push(`@Controller("actions")`);
+    }
+    if (options?.guards && options.guards.length > 0) {
+        const guardNames = options.guards.map((g) => g.name).join(", ");
+        lines.push(`@UseGuards(${guardNames})`);
+    }
+    lines.push(`export class ${action.name}ActionController {`);
+    lines.push(`  constructor(private readonly action: ${action.name}ActionAbstractService) {}`);
+    lines.push("");
+    lines.push(`  @ApiOperation({ summary: "${action.name}" })`);
+    lines.push(`  @Post("${mergedRoute}")`);
+    lines.push(`  execute(@Body() dto: ${action.name}ActionDto) {`);
+    lines.push("    return this.action.execute(dto);");
+    lines.push("  }");
+    lines.push("");
+    lines.push("}");
+    return lines.join("\n");
+}

package/dist/generators/action/dto.d.ts

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

package/dist/generators/action/dto.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionDto = generateActionDto;
+const utils_1 = require("../../utils");
+function generateActionDto(action) {
+    const kebab = (0, utils_1.toKebab)(action.name);
+    const lines = [];
+    lines.push(`export class ${action.name}ActionDto {`);
+    for (const input of action.inputs) {
+        lines.push(`  ${input.name}: ${input.type};`);
+        lines.push("");
+    }
+    lines.push("}");
+    return lines.join("\n");
+}

package/dist/generators/action/event.d.ts

@@ -0,0 +1 @@
+export declare function generateActionEvent(actionName: string, eventName: string): string;

package/dist/generators/action/event.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionEvent = generateActionEvent;
+function generateActionEvent(actionName, eventName) {
+    const lines = [];
+    lines.push(`export class ${eventName} {`);
+    lines.push("  constructor(public readonly payload: any) {}");
+    lines.push("}");
+    return lines.join("\n");
+}

package/dist/generators/action/impl.d.ts

@@ -0,0 +1,5 @@
+import type { ForgerAction } from "@forgerapi/ast";
+export declare function generateActionImpl(action: ForgerAction, options?: {
+    serviceRelative?: string;
+    dtoRelative?: string;
+}): string;

package/dist/generators/action/impl.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionImpl = generateActionImpl;
+const utils_1 = require("../../utils");
+function generateActionImpl(action, options) {
+    const kebab = (0, utils_1.toKebab)(action.name);
+    const sRel = options?.serviceRelative ?? `./${kebab}.action-service`;
+    const dRel = options?.dtoRelative ?? `./${kebab}.action-dto`;
+    const lines = [];
+    lines.push(`import { Injectable } from "@nestjs/common";`);
+    lines.push(`import { ${action.name}ActionAbstractService } from "${sRel}";`);
+    lines.push(`import { ${action.name}ActionDto } from "${dRel}";`);
+    lines.push("");
+    lines.push("@Injectable()");
+    lines.push(`export class ${action.name}ActionImplService extends ${action.name}ActionAbstractService {`);
+    lines.push("");
+    for (const step of action.steps) {
+        lines.push(`  async ${step}(dto: ${action.name}ActionDto): Promise<void> {`);
+        lines.push(`    throw new Error("Not implemented");`);
+        lines.push("  }");
+        lines.push("");
+    }
+    lines.push("}");
+    return lines.join("\n");
+}

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

@@ -0,0 +1,6 @@
+export { generateActionDto } from "./dto";
+export { generateActionService } from "./service";
+export { generateActionImpl } from "./impl";
+export { generateActionController } from "./controller";
+export { generateActionModule } from "./module";
+export { generateActionEvent } from "./event";

package/dist/generators/action/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionEvent = exports.generateActionModule = exports.generateActionController = exports.generateActionImpl = exports.generateActionService = exports.generateActionDto = void 0;
+var dto_1 = require("./dto");
+Object.defineProperty(exports, "generateActionDto", { enumerable: true, get: function () { return dto_1.generateActionDto; } });
+var service_1 = require("./service");
+Object.defineProperty(exports, "generateActionService", { enumerable: true, get: function () { return service_1.generateActionService; } });
+var impl_1 = require("./impl");
+Object.defineProperty(exports, "generateActionImpl", { enumerable: true, get: function () { return impl_1.generateActionImpl; } });
+var controller_1 = require("./controller");
+Object.defineProperty(exports, "generateActionController", { enumerable: true, get: function () { return controller_1.generateActionController; } });
+var module_1 = require("./module");
+Object.defineProperty(exports, "generateActionModule", { enumerable: true, get: function () { return module_1.generateActionModule; } });
+var event_1 = require("./event");
+Object.defineProperty(exports, "generateActionEvent", { enumerable: true, get: function () { return event_1.generateActionEvent; } });

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

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

package/dist/generators/action/module.js

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

package/dist/generators/action/service.d.ts

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

package/dist/generators/action/service.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateActionService = generateActionService;
+const utils_1 = require("../../utils");
+function generateActionService(action) {
+    const kebab = (0, utils_1.toKebab)(action.name);
+    const lines = [];
+    lines.push(`import { ${action.name}ActionDto } from "./${kebab}.action-dto";`);
+    lines.push("");
+    lines.push(`export abstract class ${action.name}ActionAbstractService {`);
+    lines.push("");
+    for (const step of action.steps) {
+        lines.push(`  abstract ${step}(dto: ${action.name}ActionDto): Promise<void>;`);
+        lines.push("");
+    }
+    lines.push(`  async execute(dto: ${action.name}ActionDto): Promise<void> {`);
+    for (const step of action.steps) {
+        lines.push(`    await this.${step}(dto);`);
+    }
+    lines.push("  }");
+    lines.push("");
+    lines.push("}");
+    return lines.join("\n");
+}

package/dist/generators/controller.d.ts

@@ -0,0 +1,3 @@
+import type { ForgerModel } from "@forgerapi/ast";
+import type { SwaggerConfig } from "./dto";
+export declare function generateController(model: ForgerModel, swagger: SwaggerConfig): string;

package/dist/generators/controller.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateController = generateController;
+const utils_1 = require("../utils");
+function generateController(model, swagger) {
+    const kebab = (0, utils_1.toKebab)(model.name);
+    const kebabPlural = `${kebab}s`;
+    const lines = [];
+    lines.push(`import { Controller, Get, Post, Body, Patch, Param, Delete } from "@nestjs/common";`);
+    if (swagger.enabled) {
+        lines.push(`import { ApiTags, ApiOperation } from "@nestjs/swagger";`);
+    }
+    lines.push(`import { ${model.name}AbstractService } from "./${kebab}.service";`);
+    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("");
+    if (swagger.enabled) {
+        lines.push(`@ApiTags("${kebabPlural}")`);
+    }
+    lines.push(`@Controller("${kebabPlural}")`);
+    lines.push(`export class ${model.name}Controller {`);
+    lines.push(`  constructor(private readonly service: ${model.name}AbstractService) {}`);
+    lines.push("");
+    if (swagger.enabled) {
+        lines.push(`  @ApiOperation({ summary: "Create a ${kebab}" })`);
+    }
+    lines.push("  @Post()");
+    lines.push(`  create(@Body() dto: Create${model.name}Dto) {`);
+    lines.push("    return this.service.create(dto);");
+    lines.push("  }");
+    lines.push("");
+    if (swagger.enabled) {
+        lines.push(`  @ApiOperation({ summary: "Get all ${kebabPlural}" })`);
+    }
+    lines.push("  @Get()");
+    lines.push("  findAll() {");
+    lines.push("    return this.service.findAll();");
+    lines.push("  }");
+    lines.push("");
+    if (swagger.enabled) {
+        lines.push(`  @ApiOperation({ summary: "Get a ${kebab} by id" })`);
+    }
+    lines.push('  @Get(":id")');
+    lines.push('  findOne(@Param("id") id: string) {');
+    lines.push("    return this.service.findOne(id);");
+    lines.push("  }");
+    lines.push("");
+    if (swagger.enabled) {
+        lines.push(`  @ApiOperation({ summary: "Update a ${kebab}" })`);
+    }
+    lines.push('  @Patch(":id")');
+    lines.push(`  update(@Param("id") id: string, @Body() dto: Update${model.name}Dto) {`);
+    lines.push("    return this.service.update(id, dto);");
+    lines.push("  }");
+    lines.push("");
+    if (swagger.enabled) {
+        lines.push(`  @ApiOperation({ summary: "Delete a ${kebab}" })`);
+    }
+    lines.push('  @Delete(":id")');
+    lines.push('  remove(@Param("id") id: string) {');
+    lines.push("    return this.service.remove(id);");
+    lines.push("  }");
+    lines.push("");
+    lines.push("}");
+    return lines.join("\n");
+}

package/dist/generators/dto.d.ts

@@ -0,0 +1,9 @@
+import type { ForgerModel, ForgerSchema } from "@forgerapi/ast";
+export interface SwaggerConfig {
+    enabled: boolean;
+}
+export declare function generateCreateDto(model: ForgerModel, schema: ForgerSchema, swagger: SwaggerConfig, options?: {
+    enumBase?: string;
+}): string;
+export declare function generateUpdateDto(model: ForgerModel): string;
+export declare function generateResponseDto(model: ForgerModel): string;

package/dist/generators/dto.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCreateDto = generateCreateDto;
+exports.generateUpdateDto = generateUpdateDto;
+exports.generateResponseDto = generateResponseDto;
+const utils_1 = require("../utils");
+function generateCreateDto(model, schema, swagger, options) {
+    const lines = [];
+    const eBase = options?.enumBase ?? "../../common/enums";
+    if (swagger.enabled) {
+        lines.push(`import { ApiProperty } from "@nestjs/swagger";`);
+    }
+    const imports = collectEnumImports(model, schema);
+    for (const imp of imports) {
+        lines.push(`import { ${imp} } from "${eBase}/${(0, utils_1.toKebab)(imp)}.enum";`);
+    }
+    if (swagger.enabled || imports.length > 0)
+        lines.push("");
+    lines.push(`export class Create${model.name}Dto {`);
+    for (const field of model.fields) {
+        if (shouldSkipInDto(field))
+            continue;
+        const tsType = toDtoTsType(field, schema);
+        const optional = isOptionalInDto(field);
+        const decorators = renderDtoDecorators(field, swagger);
+        for (const dec of decorators) {
+            lines.push(`  ${dec}`);
+        }
+        lines.push(`  ${field.name}${optional ? "?" : ""}: ${tsType};`);
+        lines.push("");
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function generateUpdateDto(model) {
+    const kebab = (0, utils_1.toKebab)(model.name);
+    return `import { PartialType } from "@nestjs/swagger";
+import { Create${model.name}Dto } from "./create-${kebab}.dto";
+
+export class Update${model.name}Dto extends PartialType(Create${model.name}Dto) {}
+`;
+}
+function generateResponseDto(model) {
+    const lines = [];
+    lines.push(`export class ${model.name}ResponseDto {`);
+    for (const field of model.fields) {
+        if (field.relation && field.relation.isArray)
+            continue;
+        const tsType = toDtoTsType(field, {
+            enums: [],
+            models: [],
+            actions: [],
+            events: [],
+            guards: [],
+            modules: [],
+        });
+        lines.push(`  ${field.name}: ${tsType};`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function shouldSkipInDto(field) {
+    if (field.constraints.some((c) => c.type === "id"))
+        return true;
+    if (field.relation && field.relation.isArray)
+        return true;
+    if (field.relation && field.relation.field)
+        return true;
+    return false;
+}
+function isOptionalInDto(field) {
+    return field.constraints.some((c) => c.type === "default");
+}
+function toDtoTsType(field, schema) {
+    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 "number";
+        case "boolean":
+            return "boolean";
+        case "uuid":
+            return "string";
+        case "datetime":
+            return "Date";
+        default:
+            return "string";
+    }
+}
+function renderDtoDecorators(field, swagger) {
+    const decorators = [];
+    if (swagger.enabled) {
+        const swaggerType = toSwaggerType(field);
+        decorators.push(`@ApiProperty({ type: ${swaggerType} })`);
+    }
+    return decorators;
+}
+function toSwaggerType(field) {
+    switch (field.type) {
+        case "string":
+            return "String";
+        case "number":
+            return "Number";
+        case "boolean":
+            return "Boolean";
+        case "uuid":
+            return "String";
+        case "datetime":
+            return "Date";
+        default:
+            return "String";
+    }
+}
+function collectEnumImports(model, schema) {
+    const names = [];
+    for (const field of model.fields) {
+        if (shouldSkipInDto(field))
+            continue;
+        const isEnum = schema.enums.some((e) => e.name === field.type);
+        if (isEnum && field.type) {
+            names.push(field.type);
+        }
+    }
+    return names.filter((v, i, a) => a.indexOf(v) === i);
+}

package/dist/generators/enum.d.ts

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

package/dist/generators/enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnum = generateEnum;
+function generateEnum(enm) {
+    const lines = [];
+    lines.push(`export enum ${enm.name} {`);
+    for (const value of enm.values) {
+        lines.push(`  ${value} = "${value}",`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+}

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

@@ -0,0 +1,6 @@
+import type { ForgerModule } from "@forgerapi/ast";
+export declare function generateForgerModule(mod: ForgerModule, options?: {
+    modelRelativeBase?: string;
+    actionBase?: string;
+    implBase?: string;
+}): string;