@autobe/compiler 0.30.0-dev.20260315 → 0.30.0

package/src/test/AutoBeTestCompiler.ts

@@ -1,112 +1,112 @@
-import {
-  AutoBeOpenApi,
-  IAutoBeTestCompiler,
-  IAutoBeTestValidateProps,
-  IAutoBeTestWriteProps,
-  IAutoBeTypeScriptCompileProps,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-import {
-  AutoBeOpenApiEndpointComparator,
-  validateTestFunction,
-} from "@autobe/utils";
-import { EmbedEsLint } from "embed-eslint";
-import { HashMap, Pair } from "tstl";
-import ts from "typescript";
-import { IValidation } from "typia";
-import typiaTransform from "typia/lib/transform";
-
-import { AutoBeCompilerInterfaceTemplate } from "../raw/AutoBeCompilerInterfaceTemplate";
-import TestExternal from "../raw/test.json";
-import { FilePrinter } from "../utils/FilePrinter";
-import { shrinkCompileResult } from "../utils/shrinkCompileResult";
-import { writeTestFunction } from "./programmers/writeTestFunction";
-
-export class AutoBeTestCompiler implements IAutoBeTestCompiler {
-  public async compile(
-    props: IAutoBeTypeScriptCompileProps,
-  ): Promise<IAutoBeTypeScriptCompileResult> {
-    const alias: string = props.package ?? "@ORGANIZATION/PROJECT-api";
-    const compiler: EmbedEsLint = new EmbedEsLint({
-      external: TestExternal as Record<string, string>,
-      compilerOptions: {
-        target: ts.ScriptTarget.ESNext,
-        module: ts.ModuleKind.CommonJS,
-        downlevelIteration: true,
-        baseUrl: "./",
-        paths: {
-          [alias]: ["./src/api"],
-          [`${alias}/lib/*`]: ["./src/api/*"],
-        },
-        strict: true,
-        skipLibCheck: true,
-        esModuleInterop: true,
-        experimentalDecorators: true,
-        emitDecoratorMetadata: true,
-        noErrorTruncation: true,
-      },
-      transformers: (program, diagnostics) => ({
-        before: [
-          typiaTransform(
-            program,
-            {},
-            {
-              addDiagnostic: (input) => diagnostics.push(input),
-            },
-          ),
-        ],
-      }),
-      rules: {
-        "no-floating-promises": "error",
-      },
-    });
-    return shrinkCompileResult(compiler.compile(props.files));
-  }
-
-  public async validate(
-    props: IAutoBeTestValidateProps,
-  ): Promise<IValidation.IError[] | null> {
-    const errors: IValidation.IError[] = [];
-    const endpoints: HashMap<
-      AutoBeOpenApi.IEndpoint,
-      AutoBeOpenApi.IOperation
-    > = new HashMap(
-      props.document.operations.map(
-        (op) =>
-          new Pair(
-            {
-              method: op.method,
-              path: op.path,
-            },
-            op,
-          ),
-      ),
-      AutoBeOpenApiEndpointComparator.hashCode,
-      AutoBeOpenApiEndpointComparator.equals,
-    );
-    validateTestFunction({
-      function: props.function,
-      document: props.document,
-      endpoints: endpoints,
-      errors,
-    });
-    return errors.length !== 0 ? errors : null;
-  }
-
-  public async write(props: IAutoBeTestWriteProps): Promise<string> {
-    const content: string = writeTestFunction(props);
-    return props.prettier === false ? content : FilePrinter.beautify(content);
-  }
-
-  public async getExternal(): Promise<Record<string, string>> {
-    return TestExternal as Record<string, string>;
-  }
-
-  public async getDefaultTypes(): Promise<Record<string, string>> {
-    return Object.fromEntries(
-      Object.entries(AutoBeCompilerInterfaceTemplate).filter(([key]) =>
-        key.startsWith("src/api/"),
-      ),
-    );
-  }
-}
+import {
+  AutoBeOpenApi,
+  IAutoBeTestCompiler,
+  IAutoBeTestValidateProps,
+  IAutoBeTestWriteProps,
+  IAutoBeTypeScriptCompileProps,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import {
+  AutoBeOpenApiEndpointComparator,
+  validateTestFunction,
+} from "@autobe/utils";
+import { EmbedEsLint } from "embed-eslint";
+import { HashMap, Pair } from "tstl";
+import ts from "typescript";
+import { IValidation } from "typia";
+import typiaTransform from "typia/lib/transform";
+
+import { AutoBeCompilerInterfaceTemplate } from "../raw/AutoBeCompilerInterfaceTemplate";
+import TestExternal from "../raw/test.json";
+import { FilePrinter } from "../utils/FilePrinter";
+import { shrinkCompileResult } from "../utils/shrinkCompileResult";
+import { writeTestFunction } from "./programmers/writeTestFunction";
+
+export class AutoBeTestCompiler implements IAutoBeTestCompiler {
+  public async compile(
+    props: IAutoBeTypeScriptCompileProps,
+  ): Promise<IAutoBeTypeScriptCompileResult> {
+    const alias: string = props.package ?? "@ORGANIZATION/PROJECT-api";
+    const compiler: EmbedEsLint = new EmbedEsLint({
+      external: TestExternal as Record<string, string>,
+      compilerOptions: {
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.CommonJS,
+        downlevelIteration: true,
+        baseUrl: "./",
+        paths: {
+          [alias]: ["./src/api"],
+          [`${alias}/lib/*`]: ["./src/api/*"],
+        },
+        strict: true,
+        skipLibCheck: true,
+        esModuleInterop: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        noErrorTruncation: true,
+      },
+      transformers: (program, diagnostics) => ({
+        before: [
+          typiaTransform(
+            program,
+            {},
+            {
+              addDiagnostic: (input) => diagnostics.push(input),
+            },
+          ),
+        ],
+      }),
+      rules: {
+        "no-floating-promises": "error",
+      },
+    });
+    return shrinkCompileResult(compiler.compile(props.files));
+  }
+
+  public async validate(
+    props: IAutoBeTestValidateProps,
+  ): Promise<IValidation.IError[] | null> {
+    const errors: IValidation.IError[] = [];
+    const endpoints: HashMap<
+      AutoBeOpenApi.IEndpoint,
+      AutoBeOpenApi.IOperation
+    > = new HashMap(
+      props.document.operations.map(
+        (op) =>
+          new Pair(
+            {
+              method: op.method,
+              path: op.path,
+            },
+            op,
+          ),
+      ),
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
+    );
+    validateTestFunction({
+      function: props.function,
+      document: props.document,
+      endpoints: endpoints,
+      errors,
+    });
+    return errors.length !== 0 ? errors : null;
+  }
+
+  public async write(props: IAutoBeTestWriteProps): Promise<string> {
+    const content: string = writeTestFunction(props);
+    return props.prettier === false ? content : FilePrinter.beautify(content);
+  }
+
+  public async getExternal(): Promise<Record<string, string>> {
+    return TestExternal as Record<string, string>;
+  }
+
+  public async getDefaultTypes(): Promise<Record<string, string>> {
+    return Object.fromEntries(
+      Object.entries(AutoBeCompilerInterfaceTemplate).filter(([key]) =>
+        key.startsWith("src/api/"),
+      ),
+    );
+  }
+}

package/src/test/programmers/AutoBeTestAccessorProgrammer.ts

@@ -1,42 +1,42 @@
-import { AutoBeTest } from "@autobe/interface";
-import ts from "typescript";
-
-import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
-import { writeTestExpression } from "./writeTestExpression";
-
-export namespace AutoBeTestAccessorProgrammer {
-  export const identifier = (
-    _ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IIdentifier,
-  ): ts.Identifier => ts.factory.createIdentifier(expr.text);
-
-  export const propertyAccessExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IPropertyAccessExpression,
-  ): ts.PropertyAccessChain | ts.PropertyAccessExpression =>
-    expr.questionDot
-      ? ts.factory.createPropertyAccessChain(
-          writeTestExpression(ctx, expr.expression),
-          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-          expr.name,
-        )
-      : ts.factory.createPropertyAccessExpression(
-          writeTestExpression(ctx, expr.expression),
-          expr.name,
-        );
-
-  export const elementAccessExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IElementAccessExpression,
-  ): ts.ElementAccessChain | ts.ElementAccessExpression =>
-    expr.questionDot
-      ? ts.factory.createElementAccessChain(
-          writeTestExpression(ctx, expr.expression),
-          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-          writeTestExpression(ctx, expr.argumentExpression),
-        )
-      : ts.factory.createElementAccessExpression(
-          writeTestExpression(ctx, expr.expression),
-          writeTestExpression(ctx, expr.argumentExpression),
-        );
-}
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+
+export namespace AutoBeTestAccessorProgrammer {
+  export const identifier = (
+    _ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IIdentifier,
+  ): ts.Identifier => ts.factory.createIdentifier(expr.text);
+
+  export const propertyAccessExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IPropertyAccessExpression,
+  ): ts.PropertyAccessChain | ts.PropertyAccessExpression =>
+    expr.questionDot
+      ? ts.factory.createPropertyAccessChain(
+          writeTestExpression(ctx, expr.expression),
+          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+          expr.name,
+        )
+      : ts.factory.createPropertyAccessExpression(
+          writeTestExpression(ctx, expr.expression),
+          expr.name,
+        );
+
+  export const elementAccessExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IElementAccessExpression,
+  ): ts.ElementAccessChain | ts.ElementAccessExpression =>
+    expr.questionDot
+      ? ts.factory.createElementAccessChain(
+          writeTestExpression(ctx, expr.expression),
+          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+          writeTestExpression(ctx, expr.argumentExpression),
+        )
+      : ts.factory.createElementAccessExpression(
+          writeTestExpression(ctx, expr.expression),
+          writeTestExpression(ctx, expr.argumentExpression),
+        );
+}

package/src/test/programmers/AutoBeTestFunctionalProgrammer.ts

@@ -1,87 +1,87 @@
-import { AutoBeTest } from "@autobe/interface";
-import ts from "typescript";
-
-import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
-import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
-import { writeTestExpression } from "./writeTestExpression";
-
-export namespace AutoBeTestFunctionalProgrammer {
-  export const arrowFunction = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IArrowFunction,
-  ): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)],
-      undefined,
-      [],
-      undefined,
-      undefined,
-      AutoBeTestStatementProgrammer.block(ctx, expr.body),
-    );
-
-  export const callExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.ICallExpression,
-  ): ts.CallExpression =>
-    ts.factory.createCallExpression(
-      writeTestExpression(ctx, expr.expression),
-      undefined,
-      expr.arguments.map((arg) => writeTestExpression(ctx, arg)),
-    );
-
-  export const newExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.INewExpression,
-  ): ts.NewExpression =>
-    ts.factory.createNewExpression(
-      writeTestExpression(ctx, expr.expression),
-      undefined,
-      expr.arguments.map((arg) => writeTestExpression(ctx, arg)),
-    );
-
-  export const arrayFilterExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IArrayFilterExpression,
-  ): ts.AwaitExpression =>
-    arrayExpression(ctx, "asyncFilter", [expr.array, expr.function]);
-
-  export const arrayForEachExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IArrayForEachExpression,
-  ): ts.AwaitExpression =>
-    arrayExpression(ctx, "asyncForEach", [expr.array, expr.function]);
-
-  export const arrayMapExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IArrayMapExpression,
-  ): ts.AwaitExpression =>
-    arrayExpression(ctx, "asyncMap", [expr.array, expr.function]);
-
-  export const arrayRepeatExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IArrayRepeatExpression,
-  ): ts.AwaitExpression =>
-    arrayExpression(ctx, "asyncRepeat", [expr.count, expr.function]);
-}
-
-const arrayExpression = (
-  ctx: IAutoBeTestProgrammerContext,
-  name: string,
-  argList: AutoBeTest.IExpression[],
-): ts.AwaitExpression =>
-  ts.factory.createAwaitExpression(
-    ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createIdentifier(
-          ctx.importer.external({
-            type: "instance",
-            library: "@nestia/e2e",
-            name: "ArrayUtil",
-          }),
-        ),
-        name,
-      ),
-      undefined,
-      argList.map((a) => writeTestExpression(ctx, a)),
-    ),
-  );
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+
+export namespace AutoBeTestFunctionalProgrammer {
+  export const arrowFunction = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IArrowFunction,
+  ): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)],
+      undefined,
+      [],
+      undefined,
+      undefined,
+      AutoBeTestStatementProgrammer.block(ctx, expr.body),
+    );
+
+  export const callExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.ICallExpression,
+  ): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      writeTestExpression(ctx, expr.expression),
+      undefined,
+      expr.arguments.map((arg) => writeTestExpression(ctx, arg)),
+    );
+
+  export const newExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.INewExpression,
+  ): ts.NewExpression =>
+    ts.factory.createNewExpression(
+      writeTestExpression(ctx, expr.expression),
+      undefined,
+      expr.arguments.map((arg) => writeTestExpression(ctx, arg)),
+    );
+
+  export const arrayFilterExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IArrayFilterExpression,
+  ): ts.AwaitExpression =>
+    arrayExpression(ctx, "asyncFilter", [expr.array, expr.function]);
+
+  export const arrayForEachExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IArrayForEachExpression,
+  ): ts.AwaitExpression =>
+    arrayExpression(ctx, "asyncForEach", [expr.array, expr.function]);
+
+  export const arrayMapExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IArrayMapExpression,
+  ): ts.AwaitExpression =>
+    arrayExpression(ctx, "asyncMap", [expr.array, expr.function]);
+
+  export const arrayRepeatExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IArrayRepeatExpression,
+  ): ts.AwaitExpression =>
+    arrayExpression(ctx, "asyncRepeat", [expr.count, expr.function]);
+}
+
+const arrayExpression = (
+  ctx: IAutoBeTestProgrammerContext,
+  name: string,
+  argList: AutoBeTest.IExpression[],
+): ts.AwaitExpression =>
+  ts.factory.createAwaitExpression(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "ArrayUtil",
+          }),
+        ),
+        name,
+      ),
+      undefined,
+      argList.map((a) => writeTestExpression(ctx, a)),
+    ),
+  );

package/src/test/programmers/AutoBeTestLiteralProgrammer.ts

@@ -1,65 +1,65 @@
-import { AutoBeTest } from "@autobe/interface";
-import { NamingConvention } from "@typia/utils";
-import ts from "typescript";
-
-import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
-import { writeTestExpression } from "./writeTestExpression";
-
-export namespace AutoBeTestLiteralProgrammer {
-  export const booleanLiteral = (
-    _ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IBooleanLiteral,
-  ): ts.BooleanLiteral =>
-    expr.value ? ts.factory.createTrue() : ts.factory.createFalse();
-
-  export const numericLiteral = (
-    _ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.INumericLiteral,
-  ): ts.NumericLiteral | ts.PrefixUnaryExpression =>
-    expr.value < 0
-      ? ts.factory.createPrefixUnaryExpression(
-          ts.SyntaxKind.MinusToken,
-          ts.factory.createNumericLiteral(-expr.value),
-        )
-      : ts.factory.createNumericLiteral(expr.value);
-
-  export const stringLiteral = (
-    _ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IStringLiteral,
-  ): ts.StringLiteral => ts.factory.createStringLiteral(expr.value);
-
-  export const arrayLiteralExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IArrayLiteralExpression,
-  ): ts.ArrayLiteralExpression =>
-    ts.factory.createArrayLiteralExpression(
-      expr.elements.map((elem) => writeTestExpression(ctx, elem)),
-      true,
-    );
-
-  export const objectLiteralExpression = (
-    ctx: IAutoBeTestProgrammerContext,
-    expr: AutoBeTest.IObjectLiteralExpression,
-  ): ts.ObjectLiteralExpression =>
-    ts.factory.createObjectLiteralExpression(
-      expr.properties.map((e) =>
-        ts.factory.createPropertyAssignment(
-          NamingConvention.variable(e.name)
-            ? ts.factory.createIdentifier(e.name)
-            : ts.factory.createStringLiteral(e.name),
-          writeTestExpression(ctx, e.value),
-        ),
-      ),
-      true,
-    );
-
-  export const nullLiteral = (
-    _ctx: IAutoBeTestProgrammerContext,
-    _expr: AutoBeTest.INullLiteral,
-  ): ts.NullLiteral => ts.factory.createNull();
-
-  export const undefinedKeyword = (
-    _ctx: IAutoBeTestProgrammerContext,
-    _expr: AutoBeTest.IUndefinedKeyword,
-  ): ts.Identifier => ts.factory.createIdentifier("undefined");
-}
+import { AutoBeTest } from "@autobe/interface";
+import { NamingConvention } from "@typia/utils";
+import ts from "typescript";
+
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+
+export namespace AutoBeTestLiteralProgrammer {
+  export const booleanLiteral = (
+    _ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IBooleanLiteral,
+  ): ts.BooleanLiteral =>
+    expr.value ? ts.factory.createTrue() : ts.factory.createFalse();
+
+  export const numericLiteral = (
+    _ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.INumericLiteral,
+  ): ts.NumericLiteral | ts.PrefixUnaryExpression =>
+    expr.value < 0
+      ? ts.factory.createPrefixUnaryExpression(
+          ts.SyntaxKind.MinusToken,
+          ts.factory.createNumericLiteral(-expr.value),
+        )
+      : ts.factory.createNumericLiteral(expr.value);
+
+  export const stringLiteral = (
+    _ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IStringLiteral,
+  ): ts.StringLiteral => ts.factory.createStringLiteral(expr.value);
+
+  export const arrayLiteralExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IArrayLiteralExpression,
+  ): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(
+      expr.elements.map((elem) => writeTestExpression(ctx, elem)),
+      true,
+    );
+
+  export const objectLiteralExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IObjectLiteralExpression,
+  ): ts.ObjectLiteralExpression =>
+    ts.factory.createObjectLiteralExpression(
+      expr.properties.map((e) =>
+        ts.factory.createPropertyAssignment(
+          NamingConvention.variable(e.name)
+            ? ts.factory.createIdentifier(e.name)
+            : ts.factory.createStringLiteral(e.name),
+          writeTestExpression(ctx, e.value),
+        ),
+      ),
+      true,
+    );
+
+  export const nullLiteral = (
+    _ctx: IAutoBeTestProgrammerContext,
+    _expr: AutoBeTest.INullLiteral,
+  ): ts.NullLiteral => ts.factory.createNull();
+
+  export const undefinedKeyword = (
+    _ctx: IAutoBeTestProgrammerContext,
+    _expr: AutoBeTest.IUndefinedKeyword,
+  ): ts.Identifier => ts.factory.createIdentifier("undefined");
+}