@autobe/compiler 0.19.1 → 0.21.0

package/src/realize/writeRealizeControllers.ts

@@ -73,6 +73,40 @@ export const writeRealizeControllers = async (
                 ),
               ],
         );
+        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,
@@ -126,7 +160,7 @@ export const writeRealizeControllers = async (
               ]
             : method.parameters,
           method.type,
-          ts.factory.createBlock([ts.factory.createReturnStatement(call)]),
+          ts.factory.createBlock([tryCatch]),
         );
       },
     },

package/src/test/AutoBeTestCompiler.ts

@@ -7,7 +7,7 @@ import {
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { AutoBeEndpointComparator, validateTestFunction } from "@autobe/utils";
-import { EmbedTypeScript, IEmbedTypeScriptResult } from "embed-typescript";
+import { EmbedEsLint } from "embed-eslint";
 import { HashMap, Pair } from "tstl";
 import ts from "typescript";
 import { IValidation } from "typia";
@@ -17,6 +17,7 @@ import { AutoBeCompilerInterfaceTemplate } from "../raw/AutoBeCompilerInterfaceT
 import { AutoBeCompilerTestTemplate } from "../raw/AutoBeCompilerTestTemplate";
 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 {
@@ -24,7 +25,7 @@ export class AutoBeTestCompiler implements IAutoBeTestCompiler {
     props: IAutoBeTypeScriptCompileProps,
   ): Promise<IAutoBeTypeScriptCompileResult> {
     const alias: string = props.package ?? "@ORGANIZATION/PROJECT-api";
-    const compiler: EmbedTypeScript = new EmbedTypeScript({
+    const compiler: EmbedEsLint = new EmbedEsLint({
       external: TestExternal as Record<string, string>,
       compilerOptions: {
         target: ts.ScriptTarget.ESNext,
@@ -53,13 +54,11 @@ export class AutoBeTestCompiler implements IAutoBeTestCompiler {
           ),
         ],
       }),
+      rules: {
+        "no-floating-promises": "error",
+      },
     });
-    const result: IEmbedTypeScriptResult = await compiler.compile(props.files);
-    return result.type === "success"
-      ? { type: "success" }
-      : result.type === "failure"
-        ? { type: "failure", diagnostics: result.diagnostics }
-        : { type: "exception", error: result.error };
+    return shrinkCompileResult(compiler.compile(props.files));
   }
 
   public async validate(

package/src/test/programmers/AutoBeTestFunctionalProgrammer.ts

@@ -1,6 +1,5 @@
 import { AutoBeTest } from "@autobe/interface";
 import ts from "typescript";
-import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 
 import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
 import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
@@ -71,8 +70,8 @@ const arrayExpression = (
   argList: AutoBeTest.IExpression[],
 ): ts.AwaitExpression =>
   ts.factory.createAwaitExpression(
-    ExpressionFactory.currying({
-      function: ts.factory.createPropertyAccessExpression(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(
           ctx.importer.external({
             type: "instance",
@@ -82,6 +81,7 @@ const arrayExpression = (
         ),
         name,
       ),
-      arguments: argList.map((a) => writeTestExpression(ctx, a)),
-    }),
+      undefined,
+      argList.map((a) => writeTestExpression(ctx, a)),
+    ),
   );

package/src/test/programmers/AutoBeTestPredicateProgrammer.ts

@@ -1,6 +1,5 @@
 import { AutoBeTest } from "@autobe/interface";
 import ts from "typescript";
-import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 
 import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
 import { writeTestExpression } from "./writeTestExpression";
@@ -10,8 +9,8 @@ export namespace AutoBeTestPredicateProgrammer {
     ctx: IAutoBeTestProgrammerContext,
     expression: AutoBeTest.IEqualPredicate,
   ): ts.CallExpression =>
-    ExpressionFactory.currying({
-      function: ts.factory.createPropertyAccessExpression(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(
           ctx.importer.external({
             type: "instance",
@@ -21,19 +20,20 @@ export namespace AutoBeTestPredicateProgrammer {
         ),
         "equals",
       ),
-      arguments: [
+      undefined,
+      [
         ts.factory.createStringLiteral(expression.title),
         writeTestExpression(ctx, expression.x),
         writeTestExpression(ctx, expression.y),
       ],
-    });
+    );
 
   export const notEqualPredicate = (
     ctx: IAutoBeTestProgrammerContext,
     expression: AutoBeTest.INotEqualPredicate,
   ): ts.CallExpression =>
-    ExpressionFactory.currying({
-      function: ts.factory.createPropertyAccessExpression(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(
           ctx.importer.external({
             type: "instance",
@@ -43,7 +43,8 @@ export namespace AutoBeTestPredicateProgrammer {
         ),
         "error",
       ),
-      arguments: [
+      undefined,
+      [
         ts.factory.createStringLiteral(expression.title),
         ts.factory.createArrowFunction(
           undefined,
@@ -59,14 +60,14 @@ export namespace AutoBeTestPredicateProgrammer {
           }),
         ),
       ],
-    });
+    );
 
   export const conditionalPredicate = (
     ctx: IAutoBeTestProgrammerContext,
     expression: AutoBeTest.IConditionalPredicate,
   ): ts.CallExpression =>
-    ExpressionFactory.currying({
-      function: ts.factory.createPropertyAccessExpression(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(
           ctx.importer.external({
             type: "instance",
@@ -76,18 +77,19 @@ export namespace AutoBeTestPredicateProgrammer {
         ),
         "predicate",
       ),
-      arguments: [
+      undefined,
+      [
         ts.factory.createStringLiteral(expression.title),
         writeTestExpression(ctx, expression.expression),
       ],
-    });
+    );
 
   export const errorPredicate = (
     ctx: IAutoBeTestProgrammerContext,
     expression: AutoBeTest.IErrorPredicate,
   ): ts.CallExpression =>
-    ExpressionFactory.currying({
-      function: ts.factory.createPropertyAccessExpression(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(
           ctx.importer.external({
             type: "instance",
@@ -97,18 +99,19 @@ export namespace AutoBeTestPredicateProgrammer {
         ),
         "error",
       ),
-      arguments: [
+      undefined,
+      [
         ts.factory.createStringLiteral(expression.title),
         writeTestExpression(ctx, expression.function),
       ],
-    });
+    );
 
   // export const httpErrorPredicate = (
   //   ctx: IAutoBeTestProgrammerContext,
   //   expression: AutoBeTest.IHttpErrorPredicate,
   // ): ts.CallExpression =>
-  //   ExpressionFactory.currying({
-  //     function: ts.factory.createPropertyAccessExpression(
+  //   ts.factory.createCallExpression(
+  //     ts.factory.createPropertyAccessExpression(
   //       ts.factory.createIdentifier(
   //         ctx.importer.external({
   //           type: "instance",
@@ -118,10 +121,11 @@ export namespace AutoBeTestPredicateProgrammer {
   //       ),
   //       "httpError",
   //     ),
-  //     arguments: [
+  //     undefined,
+  //     [
   //       ts.factory.createStringLiteral(expression.title),
   //       ts.factory.createNumericLiteral(expression.status),
   //       writeTestExpression(ctx, expression.function),
   //     ],
-  //   });
+  //   );
 }

package/src/test/programmers/AutoBeTestRandomProgrammer.ts

@@ -1,6 +1,5 @@
 import { AutoBeTest } from "@autobe/interface";
 import ts from "typescript";
-import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 
 import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
 import { writeTestExpression } from "./writeTestExpression";
@@ -29,8 +28,8 @@ export namespace AutoBeTestRandomProgrammer {
     ctx: IAutoBeTestProgrammerContext,
     expr: AutoBeTest.ISampleRandom,
   ): ts.CallExpression =>
-    ExpressionFactory.currying({
-      function: ts.factory.createPropertyAccessExpression(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(
           ctx.importer.external({
             type: "instance",
@@ -40,11 +39,12 @@ export namespace AutoBeTestRandomProgrammer {
         ),
         "sample",
       ),
-      arguments: [
+      undefined,
+      [
         writeTestExpression(ctx, expr.array),
         writeTestExpression(ctx, expr.count),
       ],
-    });
+    );
 
   export const booleanRandom = (
     _ctx: IAutoBeTestProgrammerContext,
@@ -244,22 +244,21 @@ export namespace AutoBeTestRandomProgrammer {
   export const keywordRandom = (
     ctx: IAutoBeTestProgrammerContext,
     expr: AutoBeTest.IKeywordRandom,
-  ): ts.Expression => {
-    let value: ts.Expression = ts.factory.createPropertyAccessExpression(
-      ts.factory.createIdentifier(
-        ctx.importer.external({
-          type: "instance",
-          library: "@nestia/e2e",
-          name: "RandomGenerator",
-        }),
+  ): ts.Expression =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "RandomGenerator",
+          }),
+        ),
+        expr.keyword,
       ),
-      expr.keyword,
+      undefined,
+      undefined,
     );
-    new Array(KEYWORD_CURRYING_COUNT[expr.keyword]).fill(0).forEach(() => {
-      value = ts.factory.createCallExpression(value, undefined, undefined);
-    });
-    return value;
-  };
 }
 
 const createTypiaTag = (
@@ -303,12 +302,3 @@ const createTypiaRandom = (
         : [ts.factory.createIntersectionTypeNode(typeArguments)],
     undefined,
   );
-
-const KEYWORD_CURRYING_COUNT = {
-  alphabets: 1,
-  alphaNumeric: 1,
-  mobile: 1,
-  name: 1,
-  paragraph: 2,
-  content: 3,
-};

package/src/utils/shrinkCompileResult.ts

@@ -0,0 +1,16 @@
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { IEmbedTypeScriptResult } from "embed-typescript";
+
+export const shrinkCompileResult = (
+  result: IEmbedTypeScriptResult,
+): IAutoBeTypeScriptCompileResult => {
+  if (result.type === "exception") return result;
+  else if (result.type === "success")
+    return {
+      type: "success",
+    };
+  return {
+    type: "failure",
+    diagnostics: result.diagnostics,
+  };
+};