@autobe/compiler 0.9.2 → 0.10.0

package/src/test/programmers/AutoBeTestAccessorProgrammer.ts

@@ -0,0 +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),
+        );
+}

package/src/test/programmers/AutoBeTestFunctionalProgrammer.ts

@@ -0,0 +1,87 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
+
+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(
+    ExpressionFactory.currying({
+      function: ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "ArrayUtil",
+          }),
+        ),
+        name,
+      ),
+      arguments: argList.map((a) => writeTestExpression(ctx, a)),
+    }),
+  );

package/src/test/programmers/AutoBeTestLiteralProgrammer.ts

@@ -0,0 +1,65 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+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(
+          Escaper.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");
+}

package/src/test/programmers/AutoBeTestOperatorProgrammer.ts

@@ -0,0 +1,84 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+
+export namespace AutoBeTestOperatorProgrammer {
+  export const conditionalExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IConditionalExpression,
+  ): ts.ConditionalExpression =>
+    ts.factory.createConditionalExpression(
+      writeTestExpression(ctx, expr.condition),
+      undefined,
+      writeTestExpression(ctx, expr.whenTrue),
+      undefined,
+      writeTestExpression(ctx, expr.whenFalse),
+    );
+
+  export const typeOfExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.ITypeOfExpression,
+  ): ts.TypeOfExpression =>
+    ts.factory.createTypeOfExpression(
+      writeTestExpression(ctx, expr.expression),
+    );
+
+  export const prefixUnaryExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IPrefixUnaryExpression,
+  ): ts.TypeOfExpression | ts.PrefixUnaryExpression =>
+    ts.factory.createPrefixUnaryExpression(
+      PREFIX_UNARY_OPERATORS[expr.operator],
+      writeTestExpression(ctx, expr.operand),
+    );
+
+  export const postfixUnaryExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IPostfixUnaryExpression,
+  ): ts.PostfixUnaryExpression =>
+    ts.factory.createPostfixUnaryExpression(
+      writeTestExpression(ctx, expr.operand),
+      POSTFIX_UNARY_OPERATORS[expr.operator],
+    );
+
+  export const binaryExpression = (
+    ctx: IAutoBeTestProgrammerContext,
+    expr: AutoBeTest.IBinaryExpression,
+  ): ts.BinaryExpression =>
+    ts.factory.createBinaryExpression(
+      writeTestExpression(ctx, expr.left),
+      BINARY_OPERATORS[expr.operator],
+      writeTestExpression(ctx, expr.right),
+    );
+}
+
+const POSTFIX_UNARY_OPERATORS = {
+  "++": ts.SyntaxKind.PlusPlusToken,
+  "--": ts.SyntaxKind.MinusMinusToken,
+} as const;
+
+const PREFIX_UNARY_OPERATORS = {
+  ...POSTFIX_UNARY_OPERATORS,
+  "+": ts.SyntaxKind.PlusToken,
+  "-": ts.SyntaxKind.MinusToken,
+  "!": ts.SyntaxKind.ExclamationToken,
+} as const;
+
+const BINARY_OPERATORS = {
+  "===": ts.SyntaxKind.EqualsEqualsEqualsToken,
+  "!==": ts.SyntaxKind.ExclamationEqualsEqualsToken,
+  "<": ts.SyntaxKind.LessThanToken,
+  "<=": ts.SyntaxKind.LessThanEqualsToken,
+  ">": ts.SyntaxKind.GreaterThanToken,
+  ">=": ts.SyntaxKind.GreaterThanEqualsToken,
+  "+": ts.SyntaxKind.PlusToken,
+  "-": ts.SyntaxKind.MinusToken,
+  "*": ts.SyntaxKind.AsteriskToken,
+  "/": ts.SyntaxKind.SlashToken,
+  "%": ts.SyntaxKind.PercentToken,
+  "&&": ts.SyntaxKind.AmpersandAmpersandToken,
+  "||": ts.SyntaxKind.BarBarToken,
+  instanceof: ts.SyntaxKind.InstanceOfKeyword,
+} as const;

package/src/test/programmers/AutoBeTestPredicateProgrammer.ts

@@ -0,0 +1,127 @@
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
+
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+
+export namespace AutoBeTestPredicateProgrammer {
+  export const equalPredicate = (
+    ctx: IAutoBeTestProgrammerContext,
+    expression: AutoBeTest.IEqualPredicate,
+  ): ts.CallExpression =>
+    ExpressionFactory.currying({
+      function: ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "TestValidator",
+          }),
+        ),
+        "equals",
+      ),
+      arguments: [
+        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.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "TestValidator",
+          }),
+        ),
+        "error",
+      ),
+      arguments: [
+        ts.factory.createStringLiteral(expression.title),
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [],
+          undefined,
+          undefined,
+          equalPredicate(ctx, {
+            type: "equalPredicate",
+            title: expression.title,
+            x: expression.x,
+            y: expression.y,
+          }),
+        ),
+      ],
+    });
+
+  export const conditionalPredicate = (
+    ctx: IAutoBeTestProgrammerContext,
+    expression: AutoBeTest.IConditionalPredicate,
+  ): ts.CallExpression =>
+    ExpressionFactory.currying({
+      function: ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "TestValidator",
+          }),
+        ),
+        "predicate",
+      ),
+      arguments: [
+        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.createIdentifier(
+          ctx.importer.external({
+            type: "instance",
+            library: "@nestia/e2e",
+            name: "TestValidator",
+          }),
+        ),
+        "error",
+      ),
+      arguments: [
+        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.createIdentifier(
+  //         ctx.importer.external({
+  //           type: "instance",
+  //           library: "@nestia/e2e",
+  //           name: "TestValidator",
+  //         }),
+  //       ),
+  //       "httpError",
+  //     ),
+  //     arguments: [
+  //       ts.factory.createStringLiteral(expression.title),
+  //       ts.factory.createNumericLiteral(expression.status),
+  //       writeTestExpression(ctx, expression.function),
+  //     ],
+  //   });
+}