@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/src/orchestrate/test/programmers/AutoBeTestAuthorizeProgrammer.ts

@@ -1,149 +1,149 @@
-import {
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-  AutoBeTestAuthorizeFunction,
-  AutoBeTestValidateEvent,
-  IAutoBeCompiler,
-} from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { NamingConvention } from "@typia/utils";
-import { IValidation } from "typia";
-
-import { validateEmptyCode } from "../../../utils/validateEmptyCode";
-import { IAutoBeTestArtifacts } from "../structures/IAutoBeTestArtifacts";
-import { IAutoBeTestAuthorizeProcedure } from "../structures/IAutoBeTestAuthorizeWriteResult";
-import { AutoBeTestFunctionProgrammer } from "./AutoBeTestFunctionProgrammer";
-
-export namespace AutoBeTestAuthorizeProgrammer {
-  /* ----------------------------------------------------------------
-    GETTERS
-  ---------------------------------------------------------------- */
-  export function size(document: AutoBeOpenApi.IDocument): number {
-    return document.operations.filter((op) => op.authorizationType !== null)
-      .length;
-  }
-
-  export function getFunctionName(operation: AutoBeOpenApi.IOperation): string {
-    if (
-      operation.authorizationActor === null ||
-      operation.authorizationType === null
-    )
-      throw new Error("Operation is not an authorization operation.");
-    const elements: string[] = [
-      "authorize",
-      operation.authorizationActor,
-      operation.authorizationType,
-    ];
-    return elements.map(NamingConvention.snake).join("_");
-  }
-
-  /* ----------------------------------------------------------------
-    WRITERS
-  ---------------------------------------------------------------- */
-  export function writeTemplate(props: {
-    operation: AutoBeOpenApi.IOperation;
-    schema: AutoBeOpenApi.IJsonSchema.IObject;
-  }): string {
-    if (props.operation.requestBody === null)
-      throw new Error("Authorization operation needs request body.");
-    else if (props.operation.responseBody === null)
-      throw new Error("Authorization operation needs response body.");
-
-    const functionName: string = getFunctionName(props.operation);
-    const accessor: string[] = props.operation.accessor!;
-
-    if (props.operation.authorizationActor !== "join")
-      return StringUtil.trim`
-        export async function ${functionName}(
-          connection: api.IConnection,
-          props: {
-            body: ${props.operation.requestBody.typeName}
-          },
-        ): Promise<${props.operation.responseBody.typeName}> {
-          return await api.functional.${accessor.join(".")}(
-            connection,
-            {
-              body: props.body,
-            },
-          );
-        }
-      `;
-    return StringUtil.trim`
-      export async function ${functionName}(
-        connection: api.IConnection,
-        props: {
-          body?: ${props.operation.requestBody.typeName}
-        },
-      ): Promise<${props.operation.responseBody.typeName}> {
-        const joinInput = {
-${Object.keys(props.schema.properties).map(
-  (k) =>
-    `    ${NamingConvention.variable(k) ? k : `[${JSON.stringify(k)}]`}: ...,`,
-)}
-        } satisfies ${props.operation.requestBody.typeName};
-        return await api.functional.${accessor.join(".")}(
-          connection,
-          {
-            body: joinInput,
-          },
-        );
-      }
-    `;
-  }
-
-  /* ----------------------------------------------------------------
-    COMPILERS
-  ---------------------------------------------------------------- */
-  export function compile(props: {
-    compiler: IAutoBeCompiler;
-    procedure: IAutoBeTestAuthorizeProcedure;
-    progress: AutoBeProgressEventBase;
-    step: number;
-  }): Promise<AutoBeTestValidateEvent<AutoBeTestAuthorizeFunction>> {
-    return AutoBeTestFunctionProgrammer.compile({
-      compiler: props.compiler,
-      document: props.procedure.artifacts.document,
-      function: props.procedure.function,
-      files: {
-        [props.procedure.function.location]: props.procedure.function.content,
-      },
-      progress: props.progress,
-      step: props.step,
-    });
-  }
-
-  export async function replaceImportStatements(props: {
-    compiler: IAutoBeCompiler;
-    artifacts: IAutoBeTestArtifacts;
-    content: string;
-  }): Promise<string> {
-    let code: string = await props.compiler.typescript.removeImportStatements(
-      props.content,
-    );
-    const imports: string[] =
-      AutoBeTestFunctionProgrammer.writeImportStatements(
-        props.artifacts.document.components.schemas,
-      );
-    code = [...imports, code].join("\n");
-    return await props.compiler.typescript.beautify(code);
-  }
-
-  /* ----------------------------------------------------------------
-      VALIDATE
-    ---------------------------------------------------------------- */
-  export function validate(props: {
-    procedure: IAutoBeTestAuthorizeProcedure;
-    draft: string;
-    revise: {
-      final: string | null;
-    };
-  }): IValidation.IError[] {
-    return validateEmptyCode({
-      path: "$input",
-      asynchronous: true,
-      name: props.procedure.function.name,
-      draft: props.draft,
-      revise: props.revise,
-    });
-  }
-}
+import {
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeTestAuthorizeFunction,
+  AutoBeTestValidateEvent,
+  IAutoBeCompiler,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { NamingConvention } from "@typia/utils";
+import { IValidation } from "typia";
+
+import { validateEmptyCode } from "../../../utils/validateEmptyCode";
+import { IAutoBeTestArtifacts } from "../structures/IAutoBeTestArtifacts";
+import { IAutoBeTestAuthorizeProcedure } from "../structures/IAutoBeTestAuthorizeWriteResult";
+import { AutoBeTestFunctionProgrammer } from "./AutoBeTestFunctionProgrammer";
+
+export namespace AutoBeTestAuthorizeProgrammer {
+  /* ----------------------------------------------------------------
+    GETTERS
+  ---------------------------------------------------------------- */
+  export function size(document: AutoBeOpenApi.IDocument): number {
+    return document.operations.filter((op) => op.authorizationType !== null)
+      .length;
+  }
+
+  export function getFunctionName(operation: AutoBeOpenApi.IOperation): string {
+    if (
+      operation.authorizationActor === null ||
+      operation.authorizationType === null
+    )
+      throw new Error("Operation is not an authorization operation.");
+    const elements: string[] = [
+      "authorize",
+      operation.authorizationActor,
+      operation.authorizationType,
+    ];
+    return elements.map(NamingConvention.snake).join("_");
+  }
+
+  /* ----------------------------------------------------------------
+    WRITERS
+  ---------------------------------------------------------------- */
+  export function writeTemplate(props: {
+    operation: AutoBeOpenApi.IOperation;
+    schema: AutoBeOpenApi.IJsonSchema.IObject;
+  }): string {
+    if (props.operation.requestBody === null)
+      throw new Error("Authorization operation needs request body.");
+    else if (props.operation.responseBody === null)
+      throw new Error("Authorization operation needs response body.");
+
+    const functionName: string = getFunctionName(props.operation);
+    const accessor: string[] = props.operation.accessor!;
+
+    if (props.operation.authorizationActor !== "join")
+      return StringUtil.trim`
+        export async function ${functionName}(
+          connection: api.IConnection,
+          props: {
+            body: ${props.operation.requestBody.typeName}
+          },
+        ): Promise<${props.operation.responseBody.typeName}> {
+          return await api.functional.${accessor.join(".")}(
+            connection,
+            {
+              body: props.body,
+            },
+          );
+        }
+      `;
+    return StringUtil.trim`
+      export async function ${functionName}(
+        connection: api.IConnection,
+        props: {
+          body?: ${props.operation.requestBody.typeName}
+        },
+      ): Promise<${props.operation.responseBody.typeName}> {
+        const joinInput = {
+${Object.keys(props.schema.properties).map(
+  (k) =>
+    `    ${NamingConvention.variable(k) ? k : `[${JSON.stringify(k)}]`}: ...,`,
+)}
+        } satisfies ${props.operation.requestBody.typeName};
+        return await api.functional.${accessor.join(".")}(
+          connection,
+          {
+            body: joinInput,
+          },
+        );
+      }
+    `;
+  }
+
+  /* ----------------------------------------------------------------
+    COMPILERS
+  ---------------------------------------------------------------- */
+  export function compile(props: {
+    compiler: IAutoBeCompiler;
+    procedure: IAutoBeTestAuthorizeProcedure;
+    progress: AutoBeProgressEventBase;
+    step: number;
+  }): Promise<AutoBeTestValidateEvent<AutoBeTestAuthorizeFunction>> {
+    return AutoBeTestFunctionProgrammer.compile({
+      compiler: props.compiler,
+      document: props.procedure.artifacts.document,
+      function: props.procedure.function,
+      files: {
+        [props.procedure.function.location]: props.procedure.function.content,
+      },
+      progress: props.progress,
+      step: props.step,
+    });
+  }
+
+  export async function replaceImportStatements(props: {
+    compiler: IAutoBeCompiler;
+    artifacts: IAutoBeTestArtifacts;
+    content: string;
+  }): Promise<string> {
+    let code: string = await props.compiler.typescript.removeImportStatements(
+      props.content,
+    );
+    const imports: string[] =
+      AutoBeTestFunctionProgrammer.writeImportStatements(
+        props.artifacts.document.components.schemas,
+      );
+    code = [...imports, code].join("\n");
+    return await props.compiler.typescript.beautify(code);
+  }
+
+  /* ----------------------------------------------------------------
+      VALIDATE
+    ---------------------------------------------------------------- */
+  export function validate(props: {
+    procedure: IAutoBeTestAuthorizeProcedure;
+    draft: string;
+    revise: {
+      final: string | null;
+    };
+  }): IValidation.IError[] {
+    return validateEmptyCode({
+      path: "$input",
+      asynchronous: true,
+      name: props.procedure.function.name,
+      draft: props.draft,
+      revise: props.revise,
+    });
+  }
+}

package/src/orchestrate/test/programmers/AutoBeTestFunctionProgrammer.ts

@@ -1,90 +1,90 @@
-import {
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-  AutoBeTestFunction,
-  AutoBeTestValidateEvent,
-  IAutoBeCompiler,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-import { v7 } from "uuid";
-
-export namespace AutoBeTestFunctionProgrammer {
-  export async function compile<Function extends AutoBeTestFunction>(props: {
-    compiler: IAutoBeCompiler;
-    document: AutoBeOpenApi.IDocument;
-    function: Function;
-    progress: AutoBeProgressEventBase;
-    files: Record<string, string>;
-    step: number;
-  }): Promise<AutoBeTestValidateEvent<Function>> {
-    const template: Record<string, string> = Object.fromEntries(
-      Object.entries(
-        await props.compiler.getTemplate({
-          dbms: "sqlite",
-          phase: "test",
-        }),
-      ).filter(([key]) => key.startsWith("test/utils") && key.endsWith(".ts")),
-    );
-    const artifacts: Record<string, string> =
-      await props.compiler.interface.write(props.document, []);
-    const sdk: Record<string, string> = Object.fromEntries(
-      Object.entries(artifacts).filter(
-        ([key]) =>
-          key.startsWith("src/api") && !key.startsWith("src/api/structures"),
-      ),
-    );
-    const dto: Record<string, string> = Object.fromEntries(
-      Object.entries(artifacts).filter(([key]) =>
-        key.startsWith("src/api/structures"),
-      ),
-    );
-
-    const everything: Record<string, string> = {
-      ...template,
-      ...sdk,
-      ...dto,
-      ...props.files,
-      ...(await props.compiler.test.getDefaultTypes()),
-    };
-    const result: IAutoBeTypeScriptCompileResult =
-      await props.compiler.test.compile({
-        files: everything,
-      });
-    return {
-      type: "testValidate",
-      id: v7(),
-      function: props.function,
-      result,
-      created_at: new Date().toISOString(),
-      step: props.step,
-      completed:
-        result.type === "success"
-          ? ++props.progress.completed
-          : props.progress.completed,
-      total: props.progress.total,
-    } satisfies AutoBeTestValidateEvent<Function>;
-  }
-
-  export function writeImportStatements(
-    schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
-  ): string[] {
-    const typeReferences: Set<string> = new Set(
-      Object.keys(schemas).map((key) => key.split(".")[0]!),
-    );
-    return [
-      `import { ArrayUtil, RandomGenerator, TestValidator } from "@nestia/e2e";`,
-      `import { IConnection } from "@nestia/fetcher";`,
-      `import { randint } from "tstl";`,
-      `import typia, { tags } from "typia";`,
-      `import api from "@ORGANIZATION/PROJECT-api";`,
-      `import { DeepPartial } from "@ORGANIZATION/PROJECT-api/lib/typings/DeepPartial";`,
-      `import { IEntity } from "@ORGANIZATION/PROJECT-api/lib/structures/IEntity";`,
-      ...Array.from(typeReferences)
-        .sort()
-        .map(
-          (ref) =>
-            `import type { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
-        ),
-    ];
-  }
-}
+import {
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeTestFunction,
+  AutoBeTestValidateEvent,
+  IAutoBeCompiler,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { v7 } from "uuid";
+
+export namespace AutoBeTestFunctionProgrammer {
+  export async function compile<Function extends AutoBeTestFunction>(props: {
+    compiler: IAutoBeCompiler;
+    document: AutoBeOpenApi.IDocument;
+    function: Function;
+    progress: AutoBeProgressEventBase;
+    files: Record<string, string>;
+    step: number;
+  }): Promise<AutoBeTestValidateEvent<Function>> {
+    const template: Record<string, string> = Object.fromEntries(
+      Object.entries(
+        await props.compiler.getTemplate({
+          dbms: "sqlite",
+          phase: "test",
+        }),
+      ).filter(([key]) => key.startsWith("test/utils") && key.endsWith(".ts")),
+    );
+    const artifacts: Record<string, string> =
+      await props.compiler.interface.write(props.document, []);
+    const sdk: Record<string, string> = Object.fromEntries(
+      Object.entries(artifacts).filter(
+        ([key]) =>
+          key.startsWith("src/api") && !key.startsWith("src/api/structures"),
+      ),
+    );
+    const dto: Record<string, string> = Object.fromEntries(
+      Object.entries(artifacts).filter(([key]) =>
+        key.startsWith("src/api/structures"),
+      ),
+    );
+
+    const everything: Record<string, string> = {
+      ...template,
+      ...sdk,
+      ...dto,
+      ...props.files,
+      ...(await props.compiler.test.getDefaultTypes()),
+    };
+    const result: IAutoBeTypeScriptCompileResult =
+      await props.compiler.test.compile({
+        files: everything,
+      });
+    return {
+      type: "testValidate",
+      id: v7(),
+      function: props.function,
+      result,
+      created_at: new Date().toISOString(),
+      step: props.step,
+      completed:
+        result.type === "success"
+          ? ++props.progress.completed
+          : props.progress.completed,
+      total: props.progress.total,
+    } satisfies AutoBeTestValidateEvent<Function>;
+  }
+
+  export function writeImportStatements(
+    schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+  ): string[] {
+    const typeReferences: Set<string> = new Set(
+      Object.keys(schemas).map((key) => key.split(".")[0]!),
+    );
+    return [
+      `import { ArrayUtil, RandomGenerator, TestValidator } from "@nestia/e2e";`,
+      `import { IConnection } from "@nestia/fetcher";`,
+      `import { randint } from "tstl";`,
+      `import typia, { tags } from "typia";`,
+      `import api from "@ORGANIZATION/PROJECT-api";`,
+      `import { DeepPartial } from "@ORGANIZATION/PROJECT-api/lib/typings/DeepPartial";`,
+      `import { IEntity } from "@ORGANIZATION/PROJECT-api/lib/structures/IEntity";`,
+      ...Array.from(typeReferences)
+        .sort()
+        .map(
+          (ref) =>
+            `import type { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
+        ),
+    ];
+  }
+}