@autobe/utils 0.29.2 → 0.30.0

package/src/interface/invertOpenApiDocument.ts

@@ -1,10 +1,6 @@
 import { AutoBeOpenApi } from "@autobe/interface";
-import {
-  HttpMigration,
-  IHttpMigrateApplication,
-  OpenApi,
-  OpenApiTypeChecker,
-} from "@samchon/openapi";
+import { IHttpMigrateApplication, OpenApi } from "@typia/interface";
+import { HttpMigration, OpenApiTypeChecker } from "@typia/utils";
 
 export function invertOpenApiDocument(
   document: OpenApi.IDocument,
@@ -16,18 +12,24 @@ export function invertOpenApiDocument(
       .map(
         (r) =>
           ({
-            specification: empty("specification"),
             authorizationType: null,
             method: r.method as "post",
             path: r.path,
-            summary: r.operation().summary ?? empty("summary"),
-            description: r.operation().description ?? empty("description"),
+            description:
+              writeDescription(r.operation()) ?? empty("description"),
+            specification: r.operation()
+              ? // biome-ignore lint: intended
+                ((r.operation() as any)["x-autobe-specification"] ??
+                empty("x-autobe-specification"))
+              : empty("x-autobe-specification"),
+            accessor: r.accessor,
             parameters: r.parameters.map(
               (p) =>
                 ({
                   name: p.name,
                   description:
                     p.parameter().description ?? empty("description"),
+                  // biome-ignore lint: intended
                   schema: p.schema as any,
                 }) satisfies AutoBeOpenApi.IParameter,
             ),
@@ -63,6 +65,16 @@ export function invertOpenApiDocument(
   };
 }
 
+function writeDescription(operation: OpenApi.IOperation): string | undefined {
+  if (operation.summary === undefined && operation.description === undefined)
+    return undefined;
+  if (operation.summary === undefined) return operation.description;
+  else if (operation.description === undefined) return operation.summary;
+  else if (operation.description.startsWith(operation.summary))
+    return operation.description;
+  return `${operation.summary}${operation.summary.endsWith(".") ? "" : "."}\n\n${operation.description}`;
+}
+
 function empty(key: string): string {
   return `Describe ${key} as much as possible with clear and concise words.`;
 }

package/src/interface/missedOpenApiSchemas.ts

@@ -1,5 +1,5 @@
 import { AutoBeOpenApi } from "@autobe/interface";
-import { OpenApiTypeChecker } from "@samchon/openapi";
+import { OpenApiTypeChecker } from "@typia/utils";
 
 export const missedOpenApiSchemas = (
   document: AutoBeOpenApi.IDocument,

package/src/interface/revertOpenApiAccessor.ts

@@ -1,10 +1,10 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 import {
-  HttpMigration,
   IHttpMigrateApplication,
   IHttpMigrateRoute,
   OpenApi,
-} from "@samchon/openapi";
+} from "@typia/interface";
+import { HttpMigration } from "@typia/utils";
 
 import { transformOpenApiDocument } from "./transformOpenApiDocument";
 

package/src/interface/transformOpenApiDocument.ts

@@ -1,16 +1,17 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 import {
-  HttpMigration,
   IHttpMigrateApplication,
   OpenApi,
-  OpenApiV3_1,
-} from "@samchon/openapi";
+  OpenApiV3_2,
+} from "@typia/interface";
+import { HttpMigration, OpenApiConverter } from "@typia/utils";
 import { HashMap } from "tstl";
 
+import { StringUtil } from "../StringUtil";
 import { AutoBeOpenApiEndpointComparator } from "./AutoBeOpenApiEndpointComparator";
 
 export function transformOpenApiDocument(
-  document: AutoBeOpenApi.IDocument,
+  input: AutoBeOpenApi.IDocument,
 ): OpenApi.IDocument {
   const dict: HashMap<AutoBeOpenApi.IEndpoint, string> = new HashMap(
     AutoBeOpenApiEndpointComparator.hashCode,
@@ -18,11 +19,11 @@ export function transformOpenApiDocument(
   );
   const paths: Record<string, OpenApi.IPath> = {};
 
-  for (const op of document.operations) {
+  for (const op of input.operations) {
     dict.set(op, op.name);
     paths[op.path] ??= {};
     paths[op.path][op.method] = {
-      summary: op.summary,
+      summary: StringUtil.summary(op.description),
       description:
         op.description +
         (op.authorizationType !== null &&
@@ -33,8 +34,8 @@ export function transformOpenApiDocument(
         name: p.name,
         in: "path",
         schema: p.schema,
-        description: p.description,
         required: true,
+        description: p.description,
       })),
       requestBody: op.requestBody
         ? {
@@ -64,28 +65,30 @@ export function transformOpenApiDocument(
           }
         : undefined,
       ...{
+        "x-autobe-authorization-type": op.authorizationType,
+        "x-autobe-authorization-actor": op.authorizationActor,
         "x-autobe-prerequisites": op.prerequisites,
-        "x-autobe-specification": op.specification,
         "x-samchon-accessor": op.accessor,
+        "x-autobe-specification": op.specification,
       },
     };
   }
 
-  const result: OpenApi.IDocument = OpenApi.convert({
-    openapi: "3.1.0",
+  const document: OpenApi.IDocument = OpenApiConverter.upgradeDocument({
+    openapi: "3.2.0",
     paths,
-    components: document.components,
-  } as OpenApiV3_1.IDocument);
-  const migrate: IHttpMigrateApplication = HttpMigration.application(result);
+    components: input.components,
+  } as OpenApiV3_2.IDocument);
+  const migrate: IHttpMigrateApplication = HttpMigration.application(document);
   migrate.routes.forEach((r) => {
     if (r.method === "head") return;
     const name: string = dict.get({
-      method: r.method,
+      method: r.method as "post",
       path: r.path,
     });
     if (r.accessor.length >= 2 && r.accessor.at(-2) === name) r.accessor.pop();
     r.accessor[r.accessor.length - 1] = name;
     r.operation()["x-samchon-accessor"] = r.accessor;
   });
-  return result;
+  return document;
 }

package/src/prisma/writePrismaApplication.ts

@@ -1,4 +1,4 @@
-import { AutoBePrisma } from "@autobe/interface";
+import { AutoBeDatabase } from "@autobe/interface";
 import crypto from "crypto";
 
 import { ArrayUtil } from "../ArrayUtil";
@@ -7,7 +7,7 @@ import { StringUtil } from "../StringUtil";
 
 export function writePrismaApplication(props: {
   dbms: "postgres" | "sqlite";
-  application: AutoBePrisma.IApplication;
+  application: AutoBeDatabase.IApplication;
 }): Record<string, string> {
   for (const file of props.application.files)
     for (const model of file.models) fillMappingName(model);
@@ -30,8 +30,8 @@ export function writePrismaApplication(props: {
 
 function writeFile(props: {
   dbms: "postgres" | "sqlite";
-  application: AutoBePrisma.IApplication;
-  file: AutoBePrisma.IFile;
+  application: AutoBeDatabase.IApplication;
+  file: AutoBeDatabase.IFile;
 }): string {
   return props.file.models
     .map((model) =>
@@ -45,9 +45,9 @@ function writeFile(props: {
 
 function writeModel(props: {
   dbms: "postgres" | "sqlite";
-  application: AutoBePrisma.IApplication;
-  file: AutoBePrisma.IFile;
-  model: AutoBePrisma.IModel;
+  application: AutoBeDatabase.IApplication;
+  file: AutoBeDatabase.IFile;
+  model: AutoBeDatabase.IModel;
 }): string {
   return [
     writeComment(
@@ -67,8 +67,8 @@ function writeModel(props: {
   ].join("\n");
 }
 
-function fillMappingName(model: AutoBePrisma.IModel): void {
-  const group: Map<string, AutoBePrisma.IForeignField[]> = new Map();
+function fillMappingName(model: AutoBeDatabase.IModel): void {
+  const group: Map<string, AutoBeDatabase.IForeignField[]> = new Map();
   for (const ff of model.foreignFields) {
     MapUtil.take(group, ff.relation.targetModel, () => []).push(ff);
     if (ff.relation.targetModel == model.name)
@@ -85,7 +85,7 @@ function fillMappingName(model: AutoBePrisma.IModel): void {
 ----------------------------------------------------------- */
 function writeColumns(props: {
   dbms: "postgres" | "sqlite";
-  model: AutoBePrisma.IModel;
+  model: AutoBeDatabase.IModel;
 }): string[] {
   return [
     "//----",
@@ -119,8 +119,8 @@ function writeColumns(props: {
 
 function writePrimary(props: {
   dbms: "postgres" | "sqlite";
-  model: AutoBePrisma.IModel;
-  field: AutoBePrisma.IPrimaryField;
+  model: AutoBeDatabase.IModel;
+  field: AutoBeDatabase.IPrimaryField;
 }): string {
   const type: string | undefined =
     props.dbms === "postgres" ? POSTGRES_PHYSICAL_TYPES.uuid : undefined;
@@ -137,7 +137,7 @@ function writePrimary(props: {
 
 function writeField(props: {
   dbms: "postgres" | "sqlite";
-  field: AutoBePrisma.IPlainField;
+  field: AutoBeDatabase.IPlainField;
 }): string {
   const logical: string = LOGICAL_TYPES[props.field.type];
   const physical: string | undefined =
@@ -161,12 +161,13 @@ function writeField(props: {
 ----------------------------------------------------------- */
 function writeRelations(props: {
   dbms: "postgres" | "sqlite";
-  application: AutoBePrisma.IApplication;
-  model: AutoBePrisma.IModel;
+  application: AutoBeDatabase.IApplication;
+  model: AutoBeDatabase.IModel;
 }): string[] {
   interface IHasRelationship {
     modelName: string;
     unique: boolean;
+    oppositeName: string;
     mappingName?: string;
   }
   const hasRelationships: IHasRelationship[] = props.application.files
@@ -180,12 +181,13 @@ function writeRelations(props: {
           .map((otherForeign) => ({
             modelName: otherModel.name,
             unique: otherForeign.unique,
+            oppositeName: otherForeign.relation.oppositeName,
             mappingName: otherForeign.relation.mappingName,
           })),
       ),
     )
     .flat(2);
-  const foreignIndexes: AutoBePrisma.IForeignField[] =
+  const foreignIndexes: AutoBeDatabase.IForeignField[] =
     props.model.foreignFields.filter((f) => {
       if (f.unique === true)
         return props.model.uniqueIndexes.every(
@@ -196,28 +198,52 @@ function writeRelations(props: {
         props.model.plainIndexes.every((p) => p.fieldNames[0] !== f.name)
       );
     });
-  const contents: string[][] = [
-    props.model.foreignFields.map((foreign) =>
-      writeConstraint({
-        dbms: props.dbms,
-        model: props.model,
-        foreign,
-      }),
-    ),
-    hasRelationships.map((r) =>
-      [
-        r.mappingName ?? r.modelName,
-        `${r.modelName}${r.unique ? "?" : "[]"}`,
-        ...(r.mappingName ? [`@relation("${r.mappingName}")`] : []),
-      ].join(" "),
+
+  const print = (title: string, content: string[]): string[] => {
+    if (content.length === 0) return [];
+    return [
+      // title
+      "//----",
+      ...title.split("\n").map((l) => `// ${l}`),
+      "//----",
+      // main content
+      ...content,
+    ];
+  };
+  return ArrayUtil.paddle([
+    print(
+      StringUtil.trim`
+        BELONGED RELATIONS,
+          - format: (propertyKey targetModel constraint)
+      `,
+      props.model.foreignFields.map((foreign) =>
+        writeConstraint({
+          dbms: props.dbms,
+          model: props.model,
+          foreign,
+        }),
+      ),
     ),
-    foreignIndexes.map((field) =>
-      writeForeignIndex({
-        model: props.model,
-        field,
-      }),
+    print(
+      StringUtil.trim`
+        HAS RELATIONS
+          - format: (propertyKey targetModel)
+      `,
+      hasRelationships.map((r) =>
+        [
+          r.oppositeName ?? r.mappingName ?? r.modelName, // for legacy histories
+          `${r.modelName}${r.unique ? "?" : "[]"}`,
+          ...(r.mappingName ? [`@relation("${r.mappingName}")`] : []),
+        ].join(" "),
+      ),
     ),
-    [
+    print("INDEXES", [
+      ...foreignIndexes.map((field) =>
+        writeForeignIndex({
+          model: props.model,
+          field,
+        }),
+      ),
       ...props.model.uniqueIndexes.map((unique) =>
         writeUniqueIndex({
           model: props.model,
@@ -238,22 +264,14 @@ function writeRelations(props: {
             }),
           )
         : []),
-    ],
-  ];
-  if (contents.every((c) => c.length === 0)) return [];
-  return [
-    "//----",
-    "// RELATIONS",
-    "//----",
-    // paddled content
-    ...ArrayUtil.paddle(contents),
-  ];
+    ]),
+  ]);
 }
 
 function writeConstraint(props: {
   dbms: "postgres" | "sqlite";
-  model: AutoBePrisma.IModel;
-  foreign: AutoBePrisma.IForeignField;
+  model: AutoBeDatabase.IModel;
+  foreign: AutoBeDatabase.IForeignField;
 }): string {
   // spellchecker:ignore-next-line
   const name: string = `${props.model.name}_${props.foreign.name}_rela`;
@@ -281,8 +299,8 @@ function writeConstraint(props: {
 }
 
 function writeForeignIndex(props: {
-  model: AutoBePrisma.IModel;
-  field: AutoBePrisma.IForeignField;
+  model: AutoBeDatabase.IModel;
+  field: AutoBeDatabase.IForeignField;
 }): string {
   const name: string = `${props.model.name}_${props.field.name}_fkey`;
   const prefix: string = `@@${props.field.unique === true ? "unique" : "index"}([${props.field.name}]`;
@@ -294,8 +312,8 @@ function writeForeignIndex(props: {
 }
 
 function writeUniqueIndex(props: {
-  model: AutoBePrisma.IModel;
-  unique: AutoBePrisma.IUniqueIndex;
+  model: AutoBeDatabase.IModel;
+  unique: AutoBeDatabase.IUniqueIndex;
 }): string {
   const name: string = `${props.model.name}_${props.unique.fieldNames.join("_")}_key`;
   const prefix: string = `@@unique([${props.unique.fieldNames.join(", ")}]`;
@@ -307,8 +325,8 @@ function writeUniqueIndex(props: {
 }
 
 function writePlainIndex(props: {
-  model: AutoBePrisma.IModel;
-  plain: AutoBePrisma.IPlainIndex;
+  model: AutoBeDatabase.IModel;
+  plain: AutoBeDatabase.IPlainIndex;
 }): string {
   const name: string = `${props.model.name}_${props.plain.fieldNames.join("_")}_idx`;
   const prefix: string = `@@index([${props.plain.fieldNames.join(", ")}]`;
@@ -320,8 +338,8 @@ function writePlainIndex(props: {
 }
 
 function writeGinIndex(props: {
-  model: AutoBePrisma.IModel;
-  gin: AutoBePrisma.IGinIndex;
+  model: AutoBeDatabase.IModel;
+  gin: AutoBeDatabase.IGinIndex;
 }): string {
   const name: string = `${props.model.name}_${props.gin.fieldName}_idx`;
   const prefix: string = `@@index([${props.gin.fieldName}(ops: raw("gin_trgm_ops"))], type: Gin`;
@@ -342,7 +360,6 @@ function writeComment(content: string, length: number): string {
     .split("\n")
     .map((line) => line.trim())
     .map((line) => {
-      // 77자에서 "/// " 4자를 뺀 73자가 실제 컨텐츠 최대 길이
       if (line.length <= length - 4) return [line];
       const words: string[] = line.split(" ");
       const result: string[] = [];
@@ -407,13 +424,13 @@ const POSTGRES_PHYSICAL_TYPES = {
 
 const POSTGRES_MAIN_FILE = StringUtil.trim`
   generator client {
-    provider        = "prisma-client-js"
-    engineType      = "client"
+    provider        = "prisma-client"
     previewFeatures = ["postgresqlExtensions", "views"]
+    output          = "../../src/prisma"
+    moduleFormat    = "cjs"
   }
   datasource db {
     provider   = "postgresql"
-    url        = env("DATABASE_URL")
     extensions = [pg_trgm]
   }
   generator markdown {
@@ -423,12 +440,12 @@ const POSTGRES_MAIN_FILE = StringUtil.trim`
 `;
 const SQLITE_MAIN_FILE = StringUtil.trim`
   generator client {
-    provider   = "prisma-client-js"
-    engineType = "client"
+    provider     = "prisma-client"
+    output       = "../../src/prisma"
+    moduleFormat = "cjs"
   }
   datasource db {
     provider = "sqlite"
-    url      = "file:../db.sqlite"
   }
   generator markdown {
     provider = "prisma-markdown"

package/src/test/validateTestExpression.ts

@@ -7,4 +7,10 @@ export const validateTestExpression = (
   ctx: IAutoBeTextValidateContext,
   item: AutoBeTest.IExpression,
   path: string,
-): void => AutoBeTestExpressionValidator[item.type](ctx, item as any, path);
+): void =>
+  AutoBeTestExpressionValidator[item.type](
+    ctx,
+    // biome-ignore lint: intended
+    item as any,
+    path,
+  );

package/src/test/validateTestStatement.ts

@@ -7,4 +7,10 @@ export const validateTestStatement = (
   ctx: IAutoBeTextValidateContext,
   item: AutoBeTest.IStatement,
   path: string,
-): void => AutoBeTestStatementValidator[item.type](ctx, item as any, path);
+): void =>
+  AutoBeTestStatementValidator[item.type](
+    ctx,
+    // biome-ignore lint: intended
+    item as any,
+    path,
+  );