@autobe/compiler 0.30.0-dev.20260315 → 0.30.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobe/compiler",
-  "version": "0.30.0-dev.20260315",
+  "version": "0.30.1",
   "description": "AI backend server code generator",
   "main": "lib/index.js",
   "author": "Wrtn Technologies",
@@ -32,9 +32,9 @@
     "tstl": "^3.0.0",
     "typescript-transform-paths": "^3.5.5",
     "typia": "^12.0.1",
-    "@autobe/utils": "^0.30.0-dev.20260315",
-    "@autobe/filesystem": "^0.30.0-dev.20260315",
-    "@autobe/interface": "^0.30.0-dev.20260315"
+    "@autobe/interface": "^0.30.1",
+    "@autobe/filesystem": "^0.30.1",
+    "@autobe/utils": "^0.30.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.3",

package/src/AutoBeCompiler.ts

@@ -1,93 +1,93 @@
-import {
-  AutoBePhase,
-  IAutoBeCompiler,
-  IAutoBeCompilerListener,
-  IAutoBeDatabaseCompiler,
-  IAutoBeGetFilesOptions,
-  IAutoBeInterfaceCompiler,
-  IAutoBeRealizeCompiler,
-  IAutoBeTestCompiler,
-  IAutoBeTypeScriptCompiler,
-} from "@autobe/interface";
-
-import { AutoBeTypeScriptCompiler } from "./AutoBeTypeScriptCompiler";
-import { AutoBeDatabaseCompiler } from "./database/AutoBeDatabaseCompiler";
-import { AutoBeInterfaceCompiler } from "./interface/AutoBeInterfaceCompiler";
-import { AutoBeCompilerCommonTemplate } from "./raw/AutoBeCompilerCommonTemplate";
-import { AutoBeCompilerInterfaceTemplate } from "./raw/AutoBeCompilerInterfaceTemplate";
-import { AutoBeCompilerRealizeTemplate } from "./raw/AutoBeCompilerRealizeTemplate";
-import { AutoBeCompilerRealizeTemplateOfPostgres } from "./raw/AutoBeCompilerRealizeTemplateOfPostgres";
-import { AutoBeCompilerRealizeTemplateOfSQLite } from "./raw/AutoBeCompilerRealizeTemplateOfSQLite";
-import { AutoBeCompilerTestTemplate } from "./raw/AutoBeCompilerTestTemplate";
-import { AutoBeRealizeCompiler } from "./realize/AutoBeRealizeCompiler";
-import { AutoBeTestCompiler } from "./test/AutoBeTestCompiler";
-
-/**
- * Comprehensive compilation infrastructure for the vibe coding pipeline.
- *
- * This class provides the three-tier compiler system that transforms AST
- * structures into production-ready code across all development phases. The
- * AutoBeCompiler integrates the custom Prisma compiler, Interface compiler, and
- * official TypeScript compiler into a unified compilation infrastructure.
- *
- * The compilation system ensures 100% syntactic correctness and semantic
- * integrity throughout the automated development workflow by operating on
- * validated AST data and providing continuous validation feedback loops. This
- * enables the revolutionary "structure first, validate continuously, generate
- * deterministically" approach that guarantees generated applications work
- * correctly on the first attempt.
- *
- * For high-performance scenarios with multiple concurrent users, individual
- * compiler components can be separated into dedicated worker processes to
- * prevent blocking during computationally intensive compilation operations
- * while maintaining the same interface compatibility.
- *
- * @author Samchon
- */
-export class AutoBeCompiler implements IAutoBeCompiler {
-  public database: IAutoBeDatabaseCompiler;
-  public interface: IAutoBeInterfaceCompiler;
-  public typescript: IAutoBeTypeScriptCompiler;
-  public test: IAutoBeTestCompiler;
-  public realize: IAutoBeRealizeCompiler;
-
-  public constructor(private readonly listener: IAutoBeCompilerListener) {
-    this.database = new AutoBeDatabaseCompiler();
-    this.interface = new AutoBeInterfaceCompiler();
-    this.typescript = new AutoBeTypeScriptCompiler();
-    this.test = new AutoBeTestCompiler();
-    this.realize = new AutoBeRealizeCompiler(this.listener.realize);
-  }
-
-  public async getTemplate(
-    options: Required<IAutoBeGetFilesOptions>,
-  ): Promise<Record<string, string>> {
-    const result: Record<string, string> = {
-      ...AutoBeCompilerCommonTemplate,
-    };
-    const index: number = PHASES.indexOf(options.phase);
-    if (index >= OF_INTERFACE)
-      Object.assign(result, AutoBeCompilerInterfaceTemplate);
-    if (index >= OF_TEST) Object.assign(result, AutoBeCompilerTestTemplate);
-    if (index >= OF_REALIZE)
-      Object.assign(
-        result,
-        AutoBeCompilerRealizeTemplate,
-        options.dbms === "postgres"
-          ? AutoBeCompilerRealizeTemplateOfPostgres
-          : AutoBeCompilerRealizeTemplateOfSQLite,
-      );
-    return result;
-  }
-}
-
-const PHASES: AutoBePhase[] = [
-  "analyze",
-  "database",
-  "interface",
-  "test",
-  "realize",
-];
-const OF_INTERFACE: number = PHASES.indexOf("interface");
-const OF_TEST: number = PHASES.indexOf("test");
-const OF_REALIZE: number = PHASES.indexOf("realize");
+import {
+  AutoBePhase,
+  IAutoBeCompiler,
+  IAutoBeCompilerListener,
+  IAutoBeDatabaseCompiler,
+  IAutoBeGetFilesOptions,
+  IAutoBeInterfaceCompiler,
+  IAutoBeRealizeCompiler,
+  IAutoBeTestCompiler,
+  IAutoBeTypeScriptCompiler,
+} from "@autobe/interface";
+
+import { AutoBeTypeScriptCompiler } from "./AutoBeTypeScriptCompiler";
+import { AutoBeDatabaseCompiler } from "./database/AutoBeDatabaseCompiler";
+import { AutoBeInterfaceCompiler } from "./interface/AutoBeInterfaceCompiler";
+import { AutoBeCompilerCommonTemplate } from "./raw/AutoBeCompilerCommonTemplate";
+import { AutoBeCompilerInterfaceTemplate } from "./raw/AutoBeCompilerInterfaceTemplate";
+import { AutoBeCompilerRealizeTemplate } from "./raw/AutoBeCompilerRealizeTemplate";
+import { AutoBeCompilerRealizeTemplateOfPostgres } from "./raw/AutoBeCompilerRealizeTemplateOfPostgres";
+import { AutoBeCompilerRealizeTemplateOfSQLite } from "./raw/AutoBeCompilerRealizeTemplateOfSQLite";
+import { AutoBeCompilerTestTemplate } from "./raw/AutoBeCompilerTestTemplate";
+import { AutoBeRealizeCompiler } from "./realize/AutoBeRealizeCompiler";
+import { AutoBeTestCompiler } from "./test/AutoBeTestCompiler";
+
+/**
+ * Comprehensive compilation infrastructure for the vibe coding pipeline.
+ *
+ * This class provides the three-tier compiler system that transforms AST
+ * structures into production-ready code across all development phases. The
+ * AutoBeCompiler integrates the custom Prisma compiler, Interface compiler, and
+ * official TypeScript compiler into a unified compilation infrastructure.
+ *
+ * The compilation system ensures 100% syntactic correctness and semantic
+ * integrity throughout the automated development workflow by operating on
+ * validated AST data and providing continuous validation feedback loops. This
+ * enables the revolutionary "structure first, validate continuously, generate
+ * deterministically" approach that guarantees generated applications work
+ * correctly on the first attempt.
+ *
+ * For high-performance scenarios with multiple concurrent users, individual
+ * compiler components can be separated into dedicated worker processes to
+ * prevent blocking during computationally intensive compilation operations
+ * while maintaining the same interface compatibility.
+ *
+ * @author Samchon
+ */
+export class AutoBeCompiler implements IAutoBeCompiler {
+  public database: IAutoBeDatabaseCompiler;
+  public interface: IAutoBeInterfaceCompiler;
+  public typescript: IAutoBeTypeScriptCompiler;
+  public test: IAutoBeTestCompiler;
+  public realize: IAutoBeRealizeCompiler;
+
+  public constructor(private readonly listener: IAutoBeCompilerListener) {
+    this.database = new AutoBeDatabaseCompiler();
+    this.interface = new AutoBeInterfaceCompiler();
+    this.typescript = new AutoBeTypeScriptCompiler();
+    this.test = new AutoBeTestCompiler();
+    this.realize = new AutoBeRealizeCompiler(this.listener.realize);
+  }
+
+  public async getTemplate(
+    options: Required<IAutoBeGetFilesOptions>,
+  ): Promise<Record<string, string>> {
+    const result: Record<string, string> = {
+      ...AutoBeCompilerCommonTemplate,
+    };
+    const index: number = PHASES.indexOf(options.phase);
+    if (index >= OF_INTERFACE)
+      Object.assign(result, AutoBeCompilerInterfaceTemplate);
+    if (index >= OF_TEST) Object.assign(result, AutoBeCompilerTestTemplate);
+    if (index >= OF_REALIZE)
+      Object.assign(
+        result,
+        AutoBeCompilerRealizeTemplate,
+        options.dbms === "postgres"
+          ? AutoBeCompilerRealizeTemplateOfPostgres
+          : AutoBeCompilerRealizeTemplateOfSQLite,
+      );
+    return result;
+  }
+}
+
+const PHASES: AutoBePhase[] = [
+  "analyze",
+  "database",
+  "interface",
+  "test",
+  "realize",
+];
+const OF_INTERFACE: number = PHASES.indexOf("interface");
+const OF_TEST: number = PHASES.indexOf("test");
+const OF_REALIZE: number = PHASES.indexOf("realize");

package/src/AutoBeTypeScriptCompiler.ts

@@ -1,136 +1,136 @@
-import {
-  IAutoBeTypeScriptCompileProps,
-  IAutoBeTypeScriptCompileResult,
-  IAutoBeTypeScriptCompiler,
-} from "@autobe/interface";
-import nestiaCoreTransform from "@nestia/core/lib/transform";
-import { EmbedEsLint } from "embed-eslint";
-import { Pair } from "tstl";
-// import { Pair } from "tstl";
-import ts from "typescript";
-import typiaTransform from "typia/lib/transform";
-
-import NestJSExternal from "./raw/nestjs.json";
-import { FilePrinter } from "./utils/FilePrinter";
-import { shrinkCompileResult } from "./utils/shrinkCompileResult";
-
-/**
- * Official TypeScript compiler for final code validation and quality assurance.
- *
- * This compiler provides the ultimate validation layer that ensures all
- * generated code meets production standards and integrates seamlessly with the
- * TypeScript ecosystem. While the AST-based approach eliminates most potential
- * errors before code generation, the AutoBeTypeScriptCompiler serves as the
- * final quality gate for perfect integration verification throughout the vibe
- * coding pipeline.
- *
- * The implementation validates framework integration with NestJS APIs, type
- * system integrity for complex relationships, dependency resolution across
- * modules, and build system compatibility with standard toolchains. It provides
- * comprehensive IDE support including intelligent autocomplete, real-time error
- * detection, sophisticated refactoring capabilities, and complete navigation
- * features.
- *
- * The compiler enables critical feedback loops necessary for AI self-correction
- * when implementation or test code contains compilation errors requiring
- * iterative refinement. This ensures that generated applications are
- * immediately deployable without manual debugging cycles while maintaining the
- * reliability of the automated development process.
- *
- * @author Samchon
- */
-export class AutoBeTypeScriptCompiler implements IAutoBeTypeScriptCompiler {
-  public async compile(
-    props: IAutoBeTypeScriptCompileProps,
-  ): Promise<IAutoBeTypeScriptCompileResult> {
-    const alias: string = props.package ?? "@ORGANIZATION/PROJECT-api";
-    const compiler: EmbedEsLint = new EmbedEsLint({
-      external: NestJSExternal as Record<string, string>,
-      compilerOptions: {
-        target: ts.ScriptTarget.ESNext,
-        module: ts.ModuleKind.CommonJS,
-        downlevelIteration: true,
-        baseUrl: "./",
-        paths: {
-          [alias]: ["./src/api"],
-          [`${alias}/lib/*`]: ["./src/api/*"],
-          ["@prisma/sdk"]: ["./src/prisma/client.ts"],
-        },
-        strict: true,
-        skipLibCheck: true,
-        esModuleInterop: true,
-        experimentalDecorators: true,
-        emitDecoratorMetadata: true,
-        noErrorTruncation: true,
-      },
-      transformers: (program, diagnostics) => ({
-        before: [
-          typiaTransform(
-            program,
-            {},
-            {
-              addDiagnostic: (input) => diagnostics.push(input),
-            },
-          ),
-          nestiaCoreTransform(
-            program,
-            {},
-            {
-              addDiagnostic: (input) => diagnostics.push(input),
-            },
-          ),
-        ],
-      }),
-      rules: {
-        "no-floating-promises": "error",
-      },
-    });
-    return shrinkCompileResult(
-      compiler.compile({
-        ...props.files,
-        ...(props.prisma ?? {}),
-      }),
-    );
-  }
-
-  public async getExternal(location: string): Promise<string | undefined> {
-    return (NestJSExternal as Record<string, string>)[location] ?? undefined;
-  }
-
-  public beautify(script: string): Promise<string> {
-    return FilePrinter.beautify(script);
-  }
-
-  public async removeImportStatements(script: string): Promise<string> {
-    try {
-      const sourceFile: ts.SourceFile = ts.createSourceFile(
-        "module.ts",
-        script,
-        ts.ScriptTarget.ESNext,
-        true,
-      );
-      const statements: ts.Statement[] = sourceFile.statements.filter(
-        (stmt) => stmt.kind !== ts.SyntaxKind.ImportDeclaration,
-      );
-      const printer: ts.Printer = ts.createPrinter();
-      return statements
-        .map((stmt) =>
-          printer.printNode(ts.EmitHint.Unspecified, stmt, sourceFile),
-        )
-        .join("\n");
-    } catch {
-      script = await this.beautify(script);
-      const lines: string[] = script.replaceAll("\r\n", "\n").split("\n");
-      const indexes: Pair<number, number>[] = lines
-        .map((s, i) =>
-          s.startsWith("import ")
-            ? new Pair(i, lines.slice(i).findIndex((s) => s.endsWith(";")) + i)
-            : null,
-        )
-        .filter((p) => p !== null);
-      for (const index of indexes.reverse())
-        lines.splice(index.first, index.second - index.first + 1);
-      return lines.join("\n");
-    }
-  }
-}
+import {
+  IAutoBeTypeScriptCompileProps,
+  IAutoBeTypeScriptCompileResult,
+  IAutoBeTypeScriptCompiler,
+} from "@autobe/interface";
+import nestiaCoreTransform from "@nestia/core/lib/transform";
+import { EmbedEsLint } from "embed-eslint";
+import { Pair } from "tstl";
+// import { Pair } from "tstl";
+import ts from "typescript";
+import typiaTransform from "typia/lib/transform";
+
+import NestJSExternal from "./raw/nestjs.json";
+import { FilePrinter } from "./utils/FilePrinter";
+import { shrinkCompileResult } from "./utils/shrinkCompileResult";
+
+/**
+ * Official TypeScript compiler for final code validation and quality assurance.
+ *
+ * This compiler provides the ultimate validation layer that ensures all
+ * generated code meets production standards and integrates seamlessly with the
+ * TypeScript ecosystem. While the AST-based approach eliminates most potential
+ * errors before code generation, the AutoBeTypeScriptCompiler serves as the
+ * final quality gate for perfect integration verification throughout the vibe
+ * coding pipeline.
+ *
+ * The implementation validates framework integration with NestJS APIs, type
+ * system integrity for complex relationships, dependency resolution across
+ * modules, and build system compatibility with standard toolchains. It provides
+ * comprehensive IDE support including intelligent autocomplete, real-time error
+ * detection, sophisticated refactoring capabilities, and complete navigation
+ * features.
+ *
+ * The compiler enables critical feedback loops necessary for AI self-correction
+ * when implementation or test code contains compilation errors requiring
+ * iterative refinement. This ensures that generated applications are
+ * immediately deployable without manual debugging cycles while maintaining the
+ * reliability of the automated development process.
+ *
+ * @author Samchon
+ */
+export class AutoBeTypeScriptCompiler implements IAutoBeTypeScriptCompiler {
+  public async compile(
+    props: IAutoBeTypeScriptCompileProps,
+  ): Promise<IAutoBeTypeScriptCompileResult> {
+    const alias: string = props.package ?? "@ORGANIZATION/PROJECT-api";
+    const compiler: EmbedEsLint = new EmbedEsLint({
+      external: NestJSExternal as Record<string, string>,
+      compilerOptions: {
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.CommonJS,
+        downlevelIteration: true,
+        baseUrl: "./",
+        paths: {
+          [alias]: ["./src/api"],
+          [`${alias}/lib/*`]: ["./src/api/*"],
+          ["@prisma/sdk"]: ["./src/prisma/client.ts"],
+        },
+        strict: true,
+        skipLibCheck: true,
+        esModuleInterop: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        noErrorTruncation: true,
+      },
+      transformers: (program, diagnostics) => ({
+        before: [
+          typiaTransform(
+            program,
+            {},
+            {
+              addDiagnostic: (input) => diagnostics.push(input),
+            },
+          ),
+          nestiaCoreTransform(
+            program,
+            {},
+            {
+              addDiagnostic: (input) => diagnostics.push(input),
+            },
+          ),
+        ],
+      }),
+      rules: {
+        "no-floating-promises": "error",
+      },
+    });
+    return shrinkCompileResult(
+      compiler.compile({
+        ...props.files,
+        ...(props.prisma ?? {}),
+      }),
+    );
+  }
+
+  public async getExternal(location: string): Promise<string | undefined> {
+    return (NestJSExternal as Record<string, string>)[location] ?? undefined;
+  }
+
+  public beautify(script: string): Promise<string> {
+    return FilePrinter.beautify(script);
+  }
+
+  public async removeImportStatements(script: string): Promise<string> {
+    try {
+      const sourceFile: ts.SourceFile = ts.createSourceFile(
+        "module.ts",
+        script,
+        ts.ScriptTarget.ESNext,
+        true,
+      );
+      const statements: ts.Statement[] = sourceFile.statements.filter(
+        (stmt) => stmt.kind !== ts.SyntaxKind.ImportDeclaration,
+      );
+      const printer: ts.Printer = ts.createPrinter();
+      return statements
+        .map((stmt) =>
+          printer.printNode(ts.EmitHint.Unspecified, stmt, sourceFile),
+        )
+        .join("\n");
+    } catch {
+      script = await this.beautify(script);
+      const lines: string[] = script.replaceAll("\r\n", "\n").split("\n");
+      const indexes: Pair<number, number>[] = lines
+        .map((s, i) =>
+          s.startsWith("import ")
+            ? new Pair(i, lines.slice(i).findIndex((s) => s.endsWith(";")) + i)
+            : null,
+        )
+        .filter((p) => p !== null);
+      for (const index of indexes.reverse())
+        lines.splice(index.first, index.second - index.first + 1);
+      return lines.join("\n");
+    }
+  }
+}

package/src/database/AutoBeDatabaseCompiler.ts

@@ -1,48 +1,48 @@
-import {
-  AutoBeDatabase,
-  IAutoBeDatabaseCompiler,
-  IAutoBeDatabaseValidation,
-  IAutoBePrismaCompileResult,
-  IAutoBePrismaCompilerProps,
-} from "@autobe/interface";
-import { writePrismaApplication } from "@autobe/utils";
-import { EmbedPrisma } from "embed-prisma";
-
-import { validateDatabaseApplication } from "./validateDatabaseApplication";
-
-export class AutoBeDatabaseCompiler implements IAutoBeDatabaseCompiler {
-  public async compilePrismaSchemas(
-    props: IAutoBePrismaCompilerProps,
-  ): Promise<IAutoBePrismaCompileResult> {
-    const compiler: EmbedPrisma = new EmbedPrisma();
-    const result: IAutoBePrismaCompileResult = await compiler.compile(
-      props.files,
-    );
-    if (result.type !== "success") return result;
-    return {
-      ...result,
-      client: Object.fromEntries(
-        Object.entries(result.client).map(([key, value]) => [
-          `src/prisma/${key}`,
-          value,
-        ]),
-      ),
-    };
-  }
-
-  public async writePrismaSchemas(
-    application: AutoBeDatabase.IApplication,
-    dbms: "postgres" | "sqlite" = "postgres",
-  ): Promise<Record<string, string>> {
-    return writePrismaApplication({
-      application,
-      dbms,
-    });
-  }
-
-  public async validate(
-    application: AutoBeDatabase.IApplication,
-  ): Promise<IAutoBeDatabaseValidation> {
-    return validateDatabaseApplication(application);
-  }
-}
+import {
+  AutoBeDatabase,
+  IAutoBeDatabaseCompiler,
+  IAutoBeDatabaseValidation,
+  IAutoBePrismaCompileResult,
+  IAutoBePrismaCompilerProps,
+} from "@autobe/interface";
+import { writePrismaApplication } from "@autobe/utils";
+import { EmbedPrisma } from "embed-prisma";
+
+import { validateDatabaseApplication } from "./validateDatabaseApplication";
+
+export class AutoBeDatabaseCompiler implements IAutoBeDatabaseCompiler {
+  public async compilePrismaSchemas(
+    props: IAutoBePrismaCompilerProps,
+  ): Promise<IAutoBePrismaCompileResult> {
+    const compiler: EmbedPrisma = new EmbedPrisma();
+    const result: IAutoBePrismaCompileResult = await compiler.compile(
+      props.files,
+    );
+    if (result.type !== "success") return result;
+    return {
+      ...result,
+      client: Object.fromEntries(
+        Object.entries(result.client).map(([key, value]) => [
+          `src/prisma/${key}`,
+          value,
+        ]),
+      ),
+    };
+  }
+
+  public async writePrismaSchemas(
+    application: AutoBeDatabase.IApplication,
+    dbms: "postgres" | "sqlite" = "postgres",
+  ): Promise<Record<string, string>> {
+    return writePrismaApplication({
+      application,
+      dbms,
+    });
+  }
+
+  public async validate(
+    application: AutoBeDatabase.IApplication,
+  ): Promise<IAutoBeDatabaseValidation> {
+    return validateDatabaseApplication(application);
+  }
+}