@autobe/compiler 0.30.0-dev.20260315 → 0.30.1

package/src/realize/AutoBeRealizeCompiler.ts

@@ -1,42 +1,42 @@
-import {
-  IAutoBeRealizeCompiler,
-  IAutoBeRealizeCompilerListener,
-  IAutoBeRealizeControllerProps,
-  IAutoBeRealizeTestProps,
-  IAutoBeRealizeTestResult,
-} from "@autobe/interface";
-
-import { AutoBeCompilerRealizeTemplate } from "../raw/AutoBeCompilerRealizeTemplate";
-import { FilePrinter } from "../utils/FilePrinter";
-import { testRealizeProject } from "./testRealizeProject";
-import { writeRealizeControllers } from "./writeRealizeControllers";
-
-export class AutoBeRealizeCompiler implements IAutoBeRealizeCompiler {
-  public constructor(
-    private readonly listener: IAutoBeRealizeCompilerListener,
-  ) {}
-
-  public async controller(
-    props: IAutoBeRealizeControllerProps,
-  ): Promise<Record<string, string>> {
-    const result: Record<string, string> = await writeRealizeControllers(props);
-    for (const [key, value] of Object.entries(result))
-      result[key] = await FilePrinter.beautify(value);
-    return result;
-  }
-
-  public test(
-    props: IAutoBeRealizeTestProps,
-  ): Promise<IAutoBeRealizeTestResult> {
-    return testRealizeProject(
-      {
-        ...props,
-        files: {
-          ...props.files,
-          ...AutoBeCompilerRealizeTemplate,
-        },
-      },
-      this.listener.test,
-    );
-  }
-}
+import {
+  IAutoBeRealizeCompiler,
+  IAutoBeRealizeCompilerListener,
+  IAutoBeRealizeControllerProps,
+  IAutoBeRealizeTestProps,
+  IAutoBeRealizeTestResult,
+} from "@autobe/interface";
+
+import { AutoBeCompilerRealizeTemplate } from "../raw/AutoBeCompilerRealizeTemplate";
+import { FilePrinter } from "../utils/FilePrinter";
+import { testRealizeProject } from "./testRealizeProject";
+import { writeRealizeControllers } from "./writeRealizeControllers";
+
+export class AutoBeRealizeCompiler implements IAutoBeRealizeCompiler {
+  public constructor(
+    private readonly listener: IAutoBeRealizeCompilerListener,
+  ) {}
+
+  public async controller(
+    props: IAutoBeRealizeControllerProps,
+  ): Promise<Record<string, string>> {
+    const result: Record<string, string> = await writeRealizeControllers(props);
+    for (const [key, value] of Object.entries(result))
+      result[key] = await FilePrinter.beautify(value);
+    return result;
+  }
+
+  public test(
+    props: IAutoBeRealizeTestProps,
+  ): Promise<IAutoBeRealizeTestResult> {
+    return testRealizeProject(
+      {
+        ...props,
+        files: {
+          ...props.files,
+          ...AutoBeCompilerRealizeTemplate,
+        },
+      },
+      this.listener.test,
+    );
+  }
+}

package/src/realize/testRealizeProject.ts

@@ -1,78 +1,78 @@
-import { FileSystemIterator } from "@autobe/filesystem";
-import {
-  IAutoBeRealizeTestListener,
-  IAutoBeRealizeTestProps,
-  IAutoBeRealizeTestResult,
-  IAutoBeRealizeTestService,
-} from "@autobe/interface";
-import crypto from "crypto";
-import fs from "fs";
-import os from "os";
-import { Driver, WorkerConnector } from "tgrid";
-
-import { ProcessUtil } from "../utils/ProcessUtil";
-
-export async function testRealizeProject(
-  props: IAutoBeRealizeTestProps,
-  listener: IAutoBeRealizeTestListener,
-): Promise<IAutoBeRealizeTestResult> {
-  const cwd: string = `${os.tmpdir()}/autobe-realize-${crypto.randomUUID()}`;
-  await fs.promises.mkdtemp(cwd);
-  try {
-    await setup(props.files, cwd);
-    return await test(props, listener, cwd);
-  } catch (error) {
-    throw error;
-  } finally {
-    await fs.promises.rm(cwd, {
-      recursive: true,
-      force: true,
-    });
-  }
-}
-
-async function setup(
-  files: Record<string, string>,
-  cwd: string,
-): Promise<void> {
-  await FileSystemIterator.save({
-    root: cwd,
-    files,
-  });
-
-  const exec = async (s: string) =>
-    ProcessUtil.exec(s, {
-      cwd,
-    });
-  await exec("pnpm install");
-  await exec("pnpm run build:prisma");
-  await exec("pnpm run build:test");
-}
-
-async function test(
-  props: IAutoBeRealizeTestProps,
-  listener: IAutoBeRealizeTestListener,
-  cwd: string,
-): Promise<IAutoBeRealizeTestResult> {
-  const worker: WorkerConnector<
-    null,
-    IAutoBeRealizeTestListener,
-    IAutoBeRealizeTestService
-  > = new WorkerConnector(null, listener, "process");
-  await worker.connect(`${cwd}/bin/test/servant.js`, {
-    stdio: "ignore",
-    cwd,
-  });
-  const service: Driver<IAutoBeRealizeTestService> = worker.getDriver();
-  try {
-    const result: IAutoBeRealizeTestResult = await service.execute({
-      reset: props.reset,
-      simultaneous: props.simultaneous,
-    });
-    return result;
-  } catch (error) {
-    throw error;
-  } finally {
-    await worker.close();
-  }
-}
+import { FileSystemIterator } from "@autobe/filesystem";
+import {
+  IAutoBeRealizeTestListener,
+  IAutoBeRealizeTestProps,
+  IAutoBeRealizeTestResult,
+  IAutoBeRealizeTestService,
+} from "@autobe/interface";
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import { Driver, WorkerConnector } from "tgrid";
+
+import { ProcessUtil } from "../utils/ProcessUtil";
+
+export async function testRealizeProject(
+  props: IAutoBeRealizeTestProps,
+  listener: IAutoBeRealizeTestListener,
+): Promise<IAutoBeRealizeTestResult> {
+  const cwd: string = `${os.tmpdir()}/autobe-realize-${crypto.randomUUID()}`;
+  await fs.promises.mkdtemp(cwd);
+  try {
+    await setup(props.files, cwd);
+    return await test(props, listener, cwd);
+  } catch (error) {
+    throw error;
+  } finally {
+    await fs.promises.rm(cwd, {
+      recursive: true,
+      force: true,
+    });
+  }
+}
+
+async function setup(
+  files: Record<string, string>,
+  cwd: string,
+): Promise<void> {
+  await FileSystemIterator.save({
+    root: cwd,
+    files,
+  });
+
+  const exec = async (s: string) =>
+    ProcessUtil.exec(s, {
+      cwd,
+    });
+  await exec("pnpm install");
+  await exec("pnpm run build:prisma");
+  await exec("pnpm run build:test");
+}
+
+async function test(
+  props: IAutoBeRealizeTestProps,
+  listener: IAutoBeRealizeTestListener,
+  cwd: string,
+): Promise<IAutoBeRealizeTestResult> {
+  const worker: WorkerConnector<
+    null,
+    IAutoBeRealizeTestListener,
+    IAutoBeRealizeTestService
+  > = new WorkerConnector(null, listener, "process");
+  await worker.connect(`${cwd}/bin/test/servant.js`, {
+    stdio: "ignore",
+    cwd,
+  });
+  const service: Driver<IAutoBeRealizeTestService> = worker.getDriver();
+  try {
+    const result: IAutoBeRealizeTestResult = await service.execute({
+      reset: props.reset,
+      simultaneous: props.simultaneous,
+    });
+    return result;
+  } catch (error) {
+    throw error;
+  } finally {
+    await worker.close();
+  }
+}

package/src/realize/writeRealizeControllers.ts

@@ -1,217 +1,217 @@
-import {
-  AutoBeOpenApi,
-  AutoBeRealizeAuthorization,
-  AutoBeRealizeOperationFunction,
-  IAutoBeRealizeControllerProps,
-} from "@autobe/interface";
-import { transformOpenApiDocument } from "@autobe/utils";
-import {
-  NestiaMigrateApplication,
-  NestiaMigrateNestMethodProgrammer,
-} from "@nestia/migrate";
-import path from "path";
-import ts from "typescript";
-
-import { ArrayUtil } from "../utils/ArrayUtil";
-import { FilePrinter } from "../utils/FilePrinter";
-
-export const writeRealizeControllers = async (
-  props: IAutoBeRealizeControllerProps,
-): Promise<Record<string, string>> => {
-  const app: NestiaMigrateApplication = new NestiaMigrateApplication(
-    transformOpenApiDocument(props.document),
-  );
-  const result: Record<string, string> = app.nest({
-    simulate: false,
-    e2e: false,
-    programmer: {
-      controllerMethod: (ctx) => {
-        const method: ts.MethodDeclaration =
-          NestiaMigrateNestMethodProgrammer.write(ctx);
-        const operate: AutoBeOpenApi.IOperation | undefined =
-          props.document.operations.find(
-            (o) => o.method === ctx.route.method && o.path === ctx.route.path,
-          );
-        const func: AutoBeRealizeOperationFunction | undefined = props.functions
-          .filter((f) => f.type === "operation")
-          .find(
-            (f) =>
-              f.endpoint.method === ctx.route.method &&
-              f.endpoint.path === ctx.route.path,
-          );
-        if (func === undefined || operate === undefined) return method; // unreachable
-
-        const authorization: AutoBeRealizeAuthorization | undefined =
-          operate.authorizationActor !== null &&
-          operate.authorizationType !== "join" &&
-          operate.authorizationType !== "login" &&
-          operate.authorizationType !== "refresh"
-            ? props.authorizations.find(
-                (d) => d.actor.name === operate.authorizationActor,
-              )
-            : undefined;
-
-        ctx.importer.external({
-          type: "instance",
-          library: path
-            .relative(ctx.controller.location, func.location)
-            .replaceAll(path.sep, "/")
-            .split(".ts")[0],
-          name: func.name,
-        });
-
-        const inputArguments: string[] = [
-          ...(authorization ? [authorization.actor.name] : []),
-          ...(authorization === undefined &&
-          (operate.authorizationType === "login" ||
-            operate.authorizationType === "join")
-            ? ["ip"]
-            : []),
-          ...ctx.route.parameters.map((p) => p.name),
-          ...(ctx.route.query ? [ctx.route.query.name] : []),
-          ...(ctx.route.body ? [ctx.route.body.name] : []),
-        ];
-        const call: ts.Expression = ts.factory.createCallExpression(
-          ts.factory.createIdentifier(func.name),
-          undefined,
-          inputArguments.length === 0
-            ? undefined
-            : [
-                ts.factory.createObjectLiteralExpression(
-                  inputArguments.map((name) =>
-                    ts.factory.createShorthandPropertyAssignment(name),
-                  ),
-                  true,
-                ),
-              ],
-        );
-        const tryCatch = ts.factory.createTryStatement(
-          ts.factory.createBlock(
-            [
-              ts.factory.createReturnStatement(
-                ts.factory.createAwaitExpression(call),
-              ),
-            ],
-            true,
-          ),
-          ts.factory.createCatchClause(
-            ts.factory.createVariableDeclaration(
-              ts.factory.createIdentifier("error"),
-              undefined,
-              undefined,
-              undefined,
-            ),
-            ts.factory.createBlock(
-              [
-                ts.factory.createExpressionStatement(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("console.log"),
-                    undefined,
-                    [ts.factory.createIdentifier("error")],
-                  ),
-                ),
-                ts.factory.createThrowStatement(
-                  ts.factory.createIdentifier("error"),
-                ),
-              ],
-              true,
-            ),
-          ),
-          undefined,
-        );
-        return ts.factory.updateMethodDeclaration(
-          method,
-          method.modifiers,
-          method.asteriskToken,
-          method.name,
-          method.questionToken,
-          method.typeParameters,
-          authorization !== undefined
-            ? [
-                createAuthorizationParameter(ctx, authorization),
-                ...method.parameters,
-              ]
-            : inputArguments.includes("ip")
-              ? [createIpParameter(ctx), ...method.parameters]
-              : method.parameters,
-          method.type,
-          ts.factory.createBlock([tryCatch]),
-        );
-      },
-    },
-  });
-
-  const entries: [string, string][] = await ArrayUtil.asyncMap(
-    Object.entries(result).filter(([key]) =>
-      key.startsWith("src/controllers/"),
-    ),
-    async ([key, value]) => [key, await FilePrinter.beautify(value)],
-  );
-  return Object.fromEntries(entries);
-};
-
-const createAuthorizationParameter = (
-  ctx: NestiaMigrateNestMethodProgrammer.IContext,
-  authorization: AutoBeRealizeAuthorization,
-) =>
-  ts.factory.createParameterDeclaration(
-    [
-      ts.factory.createDecorator(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier(
-            ctx.importer.external({
-              type: "instance",
-              library: path
-                .relative(
-                  ctx.controller.location,
-                  authorization.decorator.location,
-                )
-                .replaceAll(path.sep, "/")
-                .split(".ts")[0],
-              name: authorization.decorator.name,
-            }),
-          ),
-          undefined,
-          [],
-        ),
-      ),
-    ],
-    undefined,
-    authorization.actor.name,
-    undefined,
-    ts.factory.createTypeReferenceNode(
-      ctx.importer.external({
-        type: "instance",
-        library: path
-          .relative(ctx.controller.location, authorization.payload.location)
-          .replaceAll(path.sep, "/")
-          .split(".ts")[0],
-        name: authorization.payload.name,
-      }),
-    ),
-    undefined,
-  );
-
-const createIpParameter = (ctx: NestiaMigrateNestMethodProgrammer.IContext) =>
-  ts.factory.createParameterDeclaration(
-    [
-      ts.factory.createDecorator(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier(
-            ctx.importer.external({
-              type: "instance",
-              library: "@nestjs/common",
-              name: "Ip",
-            }),
-          ),
-          undefined,
-          [],
-        ),
-      ),
-    ],
-    undefined,
-    "ip",
-    undefined,
-    ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-    undefined,
-  );
+import {
+  AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeOperationFunction,
+  IAutoBeRealizeControllerProps,
+} from "@autobe/interface";
+import { transformOpenApiDocument } from "@autobe/utils";
+import {
+  NestiaMigrateApplication,
+  NestiaMigrateNestMethodProgrammer,
+} from "@nestia/migrate";
+import path from "path";
+import ts from "typescript";
+
+import { ArrayUtil } from "../utils/ArrayUtil";
+import { FilePrinter } from "../utils/FilePrinter";
+
+export const writeRealizeControllers = async (
+  props: IAutoBeRealizeControllerProps,
+): Promise<Record<string, string>> => {
+  const app: NestiaMigrateApplication = new NestiaMigrateApplication(
+    transformOpenApiDocument(props.document),
+  );
+  const result: Record<string, string> = app.nest({
+    simulate: false,
+    e2e: false,
+    programmer: {
+      controllerMethod: (ctx) => {
+        const method: ts.MethodDeclaration =
+          NestiaMigrateNestMethodProgrammer.write(ctx);
+        const operate: AutoBeOpenApi.IOperation | undefined =
+          props.document.operations.find(
+            (o) => o.method === ctx.route.method && o.path === ctx.route.path,
+          );
+        const func: AutoBeRealizeOperationFunction | undefined = props.functions
+          .filter((f) => f.type === "operation")
+          .find(
+            (f) =>
+              f.endpoint.method === ctx.route.method &&
+              f.endpoint.path === ctx.route.path,
+          );
+        if (func === undefined || operate === undefined) return method; // unreachable
+
+        const authorization: AutoBeRealizeAuthorization | undefined =
+          operate.authorizationActor !== null &&
+          operate.authorizationType !== "join" &&
+          operate.authorizationType !== "login" &&
+          operate.authorizationType !== "refresh"
+            ? props.authorizations.find(
+                (d) => d.actor.name === operate.authorizationActor,
+              )
+            : undefined;
+
+        ctx.importer.external({
+          type: "instance",
+          library: path
+            .relative(ctx.controller.location, func.location)
+            .replaceAll(path.sep, "/")
+            .split(".ts")[0],
+          name: func.name,
+        });
+
+        const inputArguments: string[] = [
+          ...(authorization ? [authorization.actor.name] : []),
+          ...(authorization === undefined &&
+          (operate.authorizationType === "login" ||
+            operate.authorizationType === "join")
+            ? ["ip"]
+            : []),
+          ...ctx.route.parameters.map((p) => p.name),
+          ...(ctx.route.query ? [ctx.route.query.name] : []),
+          ...(ctx.route.body ? [ctx.route.body.name] : []),
+        ];
+        const call: ts.Expression = ts.factory.createCallExpression(
+          ts.factory.createIdentifier(func.name),
+          undefined,
+          inputArguments.length === 0
+            ? undefined
+            : [
+                ts.factory.createObjectLiteralExpression(
+                  inputArguments.map((name) =>
+                    ts.factory.createShorthandPropertyAssignment(name),
+                  ),
+                  true,
+                ),
+              ],
+        );
+        const tryCatch = ts.factory.createTryStatement(
+          ts.factory.createBlock(
+            [
+              ts.factory.createReturnStatement(
+                ts.factory.createAwaitExpression(call),
+              ),
+            ],
+            true,
+          ),
+          ts.factory.createCatchClause(
+            ts.factory.createVariableDeclaration(
+              ts.factory.createIdentifier("error"),
+              undefined,
+              undefined,
+              undefined,
+            ),
+            ts.factory.createBlock(
+              [
+                ts.factory.createExpressionStatement(
+                  ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("console.log"),
+                    undefined,
+                    [ts.factory.createIdentifier("error")],
+                  ),
+                ),
+                ts.factory.createThrowStatement(
+                  ts.factory.createIdentifier("error"),
+                ),
+              ],
+              true,
+            ),
+          ),
+          undefined,
+        );
+        return ts.factory.updateMethodDeclaration(
+          method,
+          method.modifiers,
+          method.asteriskToken,
+          method.name,
+          method.questionToken,
+          method.typeParameters,
+          authorization !== undefined
+            ? [
+                createAuthorizationParameter(ctx, authorization),
+                ...method.parameters,
+              ]
+            : inputArguments.includes("ip")
+              ? [createIpParameter(ctx), ...method.parameters]
+              : method.parameters,
+          method.type,
+          ts.factory.createBlock([tryCatch]),
+        );
+      },
+    },
+  });
+
+  const entries: [string, string][] = await ArrayUtil.asyncMap(
+    Object.entries(result).filter(([key]) =>
+      key.startsWith("src/controllers/"),
+    ),
+    async ([key, value]) => [key, await FilePrinter.beautify(value)],
+  );
+  return Object.fromEntries(entries);
+};
+
+const createAuthorizationParameter = (
+  ctx: NestiaMigrateNestMethodProgrammer.IContext,
+  authorization: AutoBeRealizeAuthorization,
+) =>
+  ts.factory.createParameterDeclaration(
+    [
+      ts.factory.createDecorator(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            ctx.importer.external({
+              type: "instance",
+              library: path
+                .relative(
+                  ctx.controller.location,
+                  authorization.decorator.location,
+                )
+                .replaceAll(path.sep, "/")
+                .split(".ts")[0],
+              name: authorization.decorator.name,
+            }),
+          ),
+          undefined,
+          [],
+        ),
+      ),
+    ],
+    undefined,
+    authorization.actor.name,
+    undefined,
+    ts.factory.createTypeReferenceNode(
+      ctx.importer.external({
+        type: "instance",
+        library: path
+          .relative(ctx.controller.location, authorization.payload.location)
+          .replaceAll(path.sep, "/")
+          .split(".ts")[0],
+        name: authorization.payload.name,
+      }),
+    ),
+    undefined,
+  );
+
+const createIpParameter = (ctx: NestiaMigrateNestMethodProgrammer.IContext) =>
+  ts.factory.createParameterDeclaration(
+    [
+      ts.factory.createDecorator(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            ctx.importer.external({
+              type: "instance",
+              library: "@nestjs/common",
+              name: "Ip",
+            }),
+          ),
+          undefined,
+          [],
+        ),
+      ),
+    ],
+    undefined,
+    "ip",
+    undefined,
+    ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+    undefined,
+  );