@autobe/utils 0.10.0

package/lib/test/validateTestApiOperateStatement.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTestApiOperateStatement = void 0;
+const typia_1 = __importDefault(require("typia"));
+const validateTestApiOperateStatement = (ctx, stmt, path) => {
+    // Check API endpoint
+    const it = ctx.endpoints.find(stmt.endpoint);
+    if (it.equals(ctx.endpoints.end()) === true) {
+        ctx.errors.push({
+            path: `${path}.endpoint`,
+            value: stmt.endpoint,
+            expected: ctx.document.operations
+                .map((o) => `AutoBeOpenApi.IEndpoint<"${o.method}", "${o.path}">`)
+                .join(" | "),
+            description: [
+                "You can use only endpoints defined in the OpenAPI document.",
+                "",
+                ctx.document.operations
+                    .map((o) => `- { method: "${o.method}", path: "${o.path}" }`)
+                    .join("\n"),
+            ].join("\n"),
+        });
+        return;
+    }
+    const operation = it.second;
+    // Check function argument
+    const needArgument = operation.requestBody !== null || operation.parameters.length !== 0;
+    if (!!stmt.argument !== needArgument) {
+        // required argument, but is not
+        // or not required, but is provided
+        ctx.errors.push({
+            path: `${path}.argument`,
+            value: stmt.argument,
+            expected: needArgument === true
+                ? "AutoBeTest.IObjectLiteralExpression" : "null",
+        });
+    }
+    else if (!!stmt.argument) {
+        // check properties
+        const keys = new Set(stmt.argument.properties.map((p) => p.name));
+        for (const p of operation.parameters) // path parameters
+            if (keys.has(p.name) === false)
+                ctx.errors.push({
+                    path: `${path}.argument.${p.name}`,
+                    value: undefined,
+                    expected: JSON.stringify(p.schema),
+                    description: `Parameter "${p.name}" is required, and its type is ${JSON.stringify(p.schema)}. However, you did not provide it.`,
+                });
+        if (operation.requestBody !== null && keys.has("body") === false) {
+            // request body is not provided
+            ctx.errors.push({
+                path: `${path}.argument.body`,
+                value: undefined,
+                expected: operation.requestBody.typeName,
+                description: `Request body is required, and its type is "${operation.requestBody.typeName}". However, you did not provide it.`,
+            });
+        }
+    }
+    // Check function return type
+    if (!!stmt.variableName !== !!operation.responseBody) {
+        ctx.errors.push(Object.assign({ path: `${path}.variableName`, value: stmt.variableName }, (stmt.variableName === null || stmt.variableName === undefined
+            ? {
+                expected: "string",
+                description: "You have to provide variable name. Every API operations that returning value require it, and it is used to store the response body.",
+            }
+            : {
+                expected: "AutoBeTest.IIdentifier",
+                description: "You don't have to provide variable name. The API operation does not return any value, so it is not needed.",
+            })));
+    }
+};
+exports.validateTestApiOperateStatement = validateTestApiOperateStatement;
+//# sourceMappingURL=validateTestApiOperateStatement.js.map

package/lib/test/validateTestApiOperateStatement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateTestApiOperateStatement.js","sourceRoot":"","sources":["../../src/test/validateTestApiOperateStatement.ts"],"names":[],"mappings":"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"}

package/lib/test/validateTestExpression.d.ts

@@ -0,0 +1,3 @@
+import { AutoBeTest } from "@autobe/interface";
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+export declare const validateTestExpression: (ctx: IAutoBeTextValidateContext, item: AutoBeTest.IExpression, path: string) => void;

package/lib/test/validateTestExpression.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTestExpression = void 0;
+const AutoBeTestExpressionValidator_1 = require("./AutoBeTestExpressionValidator");
+const validateTestExpression = (ctx, item, path) => AutoBeTestExpressionValidator_1.AutoBeTestExpressionValidator[item.type](ctx, item, path);
+exports.validateTestExpression = validateTestExpression;
+//# sourceMappingURL=validateTestExpression.js.map

package/lib/test/validateTestExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateTestExpression.js","sourceRoot":"","sources":["../../src/test/validateTestExpression.ts"],"names":[],"mappings":";;;AAEA,mFAAgF;AAGzE,MAAM,sBAAsB,GAAG,CACpC,GAA+B,EAC/B,IAA4B,EAC5B,IAAY,EACN,EAAE,CAAC,6DAA6B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAW,EAAE,IAAI,CAAC,CAAC;AAJ/D,QAAA,sBAAsB,0BAIyC"}

package/lib/test/validateTestFunction.d.ts

@@ -0,0 +1,2 @@
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+export declare const validateTestFunction: (ctx: IAutoBeTextValidateContext) => void;

package/lib/test/validateTestFunction.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTestFunction = void 0;
+const validateTestStatement_1 = require("./validateTestStatement");
+const validateTestFunction = (ctx) => ctx.function.statements.forEach((stmt, i) => (0, validateTestStatement_1.validateTestStatement)(ctx, stmt, `$input.function.statements[${i}]`));
+exports.validateTestFunction = validateTestFunction;
+//# sourceMappingURL=validateTestFunction.js.map

package/lib/test/validateTestFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateTestFunction.js","sourceRoot":"","sources":["../../src/test/validateTestFunction.ts"],"names":[],"mappings":";;;AACA,mEAAgE;AAEzD,MAAM,oBAAoB,GAAG,CAAC,GAA+B,EAAQ,EAAE,CAC5E,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAC1C,IAAA,6CAAqB,EAAC,GAAG,EAAE,IAAI,EAAE,8BAA8B,CAAC,GAAG,CAAC,CACrE,CAAC;AAHS,QAAA,oBAAoB,wBAG7B"}

package/lib/test/validateTestStatement.d.ts

@@ -0,0 +1,3 @@
+import { AutoBeTest } from "@autobe/interface";
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+export declare const validateTestStatement: (ctx: IAutoBeTextValidateContext, item: AutoBeTest.IStatement, path: string) => void;

package/lib/test/validateTestStatement.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTestStatement = void 0;
+const AutoBeTestStatementValidator_1 = require("./AutoBeTestStatementValidator");
+const validateTestStatement = (ctx, item, path) => AutoBeTestStatementValidator_1.AutoBeTestStatementValidator[item.type](ctx, item, path);
+exports.validateTestStatement = validateTestStatement;
+//# sourceMappingURL=validateTestStatement.js.map

package/lib/test/validateTestStatement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateTestStatement.js","sourceRoot":"","sources":["../../src/test/validateTestStatement.ts"],"names":[],"mappings":";;;AAEA,iFAA8E;AAGvE,MAAM,qBAAqB,GAAG,CACnC,GAA+B,EAC/B,IAA2B,EAC3B,IAAY,EACN,EAAE,CAAC,2DAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAW,EAAE,IAAI,CAAC,CAAC;AAJ9D,QAAA,qBAAqB,yBAIyC"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@autobe/utils",
+  "version": "0.10.0",
+  "description": "AI backend server code generator",
+  "main": "lib/index.js",
+  "keywords": [],
+  "author": "Wrtn Technologies",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wrtnlabs/autobe"
+  },
+  "bugs": {
+    "url": "https://github.com/wrtnlabs/autobe/issues"
+  },
+  "files": [
+    "lib",
+    "src",
+    "package.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@samchon/openapi": "^4.4.1",
+    "tstl": "^3.0.0",
+    "typia": "^9.4.0",
+    "@autobe/interface": "^0.10.0"
+  },
+  "devDependencies": {
+    "rimraf": "^6.0.1",
+    "ts-patch": "^3.3.0",
+    "typescript": "~5.8.3"
+  },
+  "scripts": {
+    "build": "rimraf lib && tsc",
+    "dev": "rimraf lib && tsc --watch"
+  },
+  "typings": "lib/index.d.ts"
+}

package/src/StringUtil.ts

@@ -0,0 +1,45 @@
+export namespace StringUtil {
+  export function trim(
+    strings: TemplateStringsArray,
+    ...values: any[]
+  ): string {
+    let result: string = strings[0];
+    for (let i = 0; i < values.length; i++) {
+      result += String(values[i]) + strings[i + 1];
+    }
+
+    const lines: string[] = result.split("\n");
+    while (lines.length > 0 && lines[0].trim() === "") {
+      lines.shift();
+    }
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+      lines.pop();
+    }
+    if (lines.length === 0) return "";
+
+    const firstNonEmptyLine: string | undefined = lines.find(
+      (line) => line.trim() !== "",
+    );
+    if (!firstNonEmptyLine) return "";
+
+    const leadingWhitespace: string =
+      firstNonEmptyLine.match(/^[ \t]*/)?.[0] || "";
+    const indentLength: number = leadingWhitespace.length;
+    const trimmedLines: string[] = lines.map((line) => {
+      if (line.trim() === "") return "";
+      return line.slice(indentLength);
+    });
+    return trimmedLines.join("\n");
+  }
+
+  export function singleLine(
+    strings: TemplateStringsArray,
+    ...values: any[]
+  ): string {
+    let result: string = strings[0];
+    for (let i = 0; i < values.length; i++) {
+      result += String(values[i]) + strings[i + 1];
+    }
+    return result.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./interface";
+export * from "./test";
+
+export * from "./StringUtil";

package/src/interface/AutoBeEndpointComparator.ts

@@ -0,0 +1,12 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { hash } from "tstl";
+
+export namespace AutoBeEndpointComparator {
+  export const equals = (
+    x: AutoBeOpenApi.IEndpoint,
+    y: AutoBeOpenApi.IEndpoint,
+  ): boolean => x.method === y.method && x.path === y.path;
+
+  export const hashCode = (endpoint: AutoBeOpenApi.IEndpoint): number =>
+    hash(endpoint.path, endpoint.method);
+}

package/src/interface/index.ts

@@ -0,0 +1,3 @@
+export * from "./AutoBeEndpointComparator";
+export * from "./invertOpenApiDocument";
+export * from "./transformOpenApiDocument";

package/src/interface/invertOpenApiDocument.ts

@@ -0,0 +1,67 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import {
+  HttpMigration,
+  IHttpMigrateApplication,
+  OpenApi,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+
+export function invertOpenApiDocument(
+  document: OpenApi.IDocument,
+): AutoBeOpenApi.IDocument {
+  const app: IHttpMigrateApplication = HttpMigration.application(document);
+  return {
+    operations: app.routes
+      .filter((r) => r.query === null)
+      .map(
+        (r) =>
+          ({
+            specification: empty("specification"),
+            method: r.method as "post",
+            path: r.path,
+            summary: r.operation().summary ?? empty("summary"),
+            description: r.operation().description ?? empty("description"),
+            parameters: r.parameters.map(
+              (p) =>
+                ({
+                  name: p.name,
+                  description:
+                    p.parameter().description ?? empty("description"),
+                  schema: p.schema as any,
+                }) satisfies AutoBeOpenApi.IParameter,
+            ),
+            requestBody:
+              r.body?.type === "application/json" &&
+              OpenApiTypeChecker.isReference(r.body.schema)
+                ? {
+                    description: r.body.description() ?? empty("description"),
+                    typeName: r.body.schema.$ref.split("/").pop()!,
+                  }
+                : null,
+            responseBody:
+              r.success?.type === "application/json" &&
+              OpenApiTypeChecker.isReference(r.success.schema)
+                ? {
+                    description:
+                      r.success.description() ?? empty("description"),
+                    typeName: r.success.schema.$ref.split("/").pop()!,
+                  }
+                : null,
+            authorization: {
+              role: [],
+              type: "Bearer",
+            },
+          }) satisfies AutoBeOpenApi.IOperation,
+      ),
+    components: {
+      schemas: (document.components?.schemas ?? {}) as Record<
+        string,
+        AutoBeOpenApi.IJsonSchemaDescriptive
+      >,
+    },
+  };
+}
+
+function empty(key: string): string {
+  return `Describe ${key} as much as possible with clear and concise words.`;
+}

package/src/interface/transformOpenApiDocument.ts

@@ -0,0 +1,54 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { OpenApi, OpenApiV3_1 } from "@samchon/openapi";
+
+export function transformOpenApiDocument(
+  document: AutoBeOpenApi.IDocument,
+): OpenApi.IDocument {
+  const paths: Record<string, OpenApi.IPath> = {};
+  for (const op of document.operations) {
+    paths[op.path] ??= {};
+    paths[op.path][op.method] = {
+      summary: op.summary,
+      description: op.description,
+      parameters: op.parameters.map((p) => ({
+        name: p.name,
+        in: "path",
+        schema: p.schema,
+        description: p.description,
+        required: true,
+      })),
+      requestBody: op.requestBody
+        ? {
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: `#/components/schemas/${op.requestBody.typeName}`,
+                },
+              },
+            },
+            description: op.requestBody.description,
+            required: true,
+          }
+        : undefined,
+      responses: op.responseBody
+        ? {
+            [op.method === "post" ? 201 : 200]: {
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: `#/components/schemas/${op.responseBody.typeName}`,
+                  },
+                },
+              },
+              description: op.responseBody.description,
+            },
+          }
+        : undefined,
+    };
+  }
+  return OpenApi.convert({
+    openapi: "3.1.0",
+    paths,
+    components: document.components,
+  } as OpenApiV3_1.IDocument);
+}

package/src/test/AutoBeTestExpressionValidator.ts

@@ -0,0 +1,253 @@
+import { AutoBeTest } from "@autobe/interface";
+
+import { AutoBeTestStatementValidator } from "./AutoBeTestStatementValidator";
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+import { validateTestExpression } from "./validateTestExpression";
+
+export namespace AutoBeTestExpressionValidator {
+  /* -----------------------------------------------------------
+    LITERALS
+  ----------------------------------------------------------- */
+  export const booleanLiteral = (): void => {};
+  export const numericLiteral = (): void => {};
+  export const stringLiteral = (): void => {};
+  export const nullLiteral = (): void => {};
+  export const undefinedKeyword = (): void => {};
+
+  export const arrayLiteralExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayLiteralExpression,
+    path: string,
+  ): void => {
+    item.elements.forEach((element, i) => {
+      validateTestExpression(ctx, element, `${path}.elements[${i}]`);
+    });
+  };
+
+  export const objectLiteralExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IObjectLiteralExpression,
+    path: string,
+  ): void => {
+    item.properties.forEach((property, i) => {
+      validateTestExpression(ctx, property.value, `${path}.properties[${i}]`);
+    });
+  };
+
+  /* -----------------------------------------------------------
+    ACCESSORS
+  ----------------------------------------------------------- */
+  export const identifier = (): void => {};
+
+  export const propertyAccessExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPropertyAccessExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const elementAccessExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IElementAccessExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+    validateTestExpression(
+      ctx,
+      item.argumentExpression,
+      `${path}.argumentExpression`,
+    );
+  };
+
+  /* -----------------------------------------------------------
+    OPERATORS
+  ----------------------------------------------------------- */
+  export const typeOfExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.ITypeOfExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const prefixUnaryExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPrefixUnaryExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.operand, `${path}.operand`);
+  };
+
+  export const postfixUnaryExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPostfixUnaryExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.operand, `${path}.operand`);
+  };
+
+  export const binaryExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IBinaryExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.left, `${path}.left`);
+    validateTestExpression(ctx, item.right, `${path}.right`);
+  };
+
+  export const conditionalExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IConditionalExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.condition, `${path}.condition`);
+    validateTestExpression(ctx, item.whenTrue, `${path}.whenTrue`);
+    validateTestExpression(ctx, item.whenFalse, `${path}.whenFalse`);
+  };
+
+  /* -----------------------------------------------------------
+    FUNCTIONAL
+  ----------------------------------------------------------- */
+  export const arrowFunction = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrowFunction,
+    path: string,
+  ): void => {
+    AutoBeTestStatementValidator.block(ctx, item.body, `${path}.body`);
+  };
+
+  export const callExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.ICallExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+    item.arguments.forEach((arg, i) => {
+      validateTestExpression(ctx, arg, `${path}.arguments[${i}]`);
+    });
+  };
+
+  export const newExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.INewExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+    item.arguments.forEach((arg, i) => {
+      validateTestExpression(ctx, arg, `${path}.arguments[${i}]`);
+    });
+  };
+
+  export const arrayFilterExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayFilterExpression,
+    path: string,
+  ): void => arrayClosureExpression(ctx, item, path);
+
+  export const arrayForEachExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayForEachExpression,
+    path: string,
+  ): void => arrayClosureExpression(ctx, item, path);
+
+  export const arrayMapExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayMapExpression,
+    path: string,
+  ): void => arrayClosureExpression(ctx, item, path);
+
+  export const arrayRepeatExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayRepeatExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.count, `${path}.length`);
+    arrowFunction(ctx, item.function, `${path}.function`);
+  };
+
+  const arrayClosureExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: {
+      array: AutoBeTest.IExpression;
+      function: AutoBeTest.IArrowFunction;
+    },
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.array, `${path}.expression`);
+    arrowFunction(ctx, item.function, `${path}.function`);
+  };
+
+  /* -----------------------------------------------------------
+    RANDOM GENERATORS
+  ----------------------------------------------------------- */
+  export const pickRandom = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPickRandom,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.array, `${path}.expression`);
+  };
+
+  export const sampleRandom = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.ISampleRandom,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.array, `${path}.expression`);
+    validateTestExpression(ctx, item.count, `${path}.length`);
+  };
+
+  export const booleanRandom = (): void => {};
+  export const integerRandom = (): void => {};
+  export const numberRandom = (): void => {};
+  export const stringRandom = (): void => {};
+  export const patternRandom = (): void => {};
+  export const formatRandom = (): void => {};
+  export const keywordRandom = (): void => {};
+
+  /* -----------------------------------------------------------
+    PREDICATORS
+  ----------------------------------------------------------- */
+  export const equalPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IEqualPredicate,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.x, `${path}.x`);
+    validateTestExpression(ctx, item.y, `${path}.y`);
+  };
+
+  export const notEqualPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.INotEqualPredicate,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.x, `${path}.x`);
+    validateTestExpression(ctx, item.y, `${path}.y`);
+  };
+
+  export const conditionalPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IConditionalPredicate,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.condition`);
+  };
+
+  export const errorPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IErrorPredicate,
+    path: string,
+  ): void => {
+    arrowFunction(ctx, item.function, `${path}.function`);
+  };
+
+  // export const httpErrorPredicate = (
+  //   ctx: IAutoBeTextValidateContext,
+  //   item: AutoBeTest.IHttpErrorPredicate,
+  //   path: string,
+  // ): void => {
+  //   arrowFunction(ctx, item.function, `${path}.function`);
+  // };
+}