@autobe/agent 0.19.1 → 0.21.0

package/src/orchestrate/interface/orchestrateInterfaceOperationsReview.ts

@@ -2,11 +2,13 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeInterfaceOperationsReviewEvent,
   AutoBeOpenApi,
+  AutoBePrisma,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { transformInterfaceOperationsReviewHistories } from "./histories/transformInterfaceOperationsReviewHistories";
@@ -20,6 +22,7 @@ export async function orchestrateInterfaceOperationsReview<
   progress: AutoBeProgressEventBase,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   try {
+    const files: AutoBePrisma.IFile[] = ctx.state().prisma?.result.data.files!;
     const pointer: IPointer<IAutoBeInterfaceOperationsReviewApplication.IProps | null> =
       {
         value: null,
@@ -29,6 +32,7 @@ export async function orchestrateInterfaceOperationsReview<
       histories: transformInterfaceOperationsReviewHistories(ctx, operations),
       controller: createReviewController({
         model: ctx.model,
+        prismaSchemas: files,
         build: (next: IAutoBeInterfaceOperationsReviewApplication.IProps) => {
           pointer.value = next;
         },
@@ -51,6 +55,7 @@ export async function orchestrateInterfaceOperationsReview<
 
     ctx.dispatch({
       type: "interfaceOperationsReview",
+      id: v7(),
       operations: content,
       review: pointer.value.review,
       plan: pointer.value.plan,
@@ -71,11 +76,102 @@ export async function orchestrateInterfaceOperationsReview<
 
 function createReviewController<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  prismaSchemas: AutoBePrisma.IFile[];
   build: (reviews: IAutoBeInterfaceOperationsReviewApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> =
+      typia.validate<IAutoBeInterfaceOperationsReviewApplication.IProps>(next);
+    if (result.success === false) return result;
+    const errors: IValidation.IError[] = [];
+
+    const models: AutoBePrisma.IModel[] = props.prismaSchemas.flatMap(
+      (schema) => schema.models,
+    );
+
+    result.data.content.forEach((op, index) => {
+      // Check if summary or description mentions soft delete
+      const mentionsSoftDelete =
+        (op.summary && /soft[\s-]?delet/i.test(op.summary)) ||
+        (op.description && /soft[\s-]?delet/i.test(op.description));
+
+      if (op.method === "delete") {
+        const model = models.find((model) => model.name === op.model_name);
+
+        if (mentionsSoftDelete) {
+          // If soft delete is mentioned but no soft_delete_column is specified
+          if (!op.soft_delete_column) {
+            // Check if any soft-delete capable column exists in the model
+            const hasSoftDeleteCapableColumn = model?.plainFields.some(
+              (field) =>
+                /delete|deleted|deleted_at|deletedAt|is_deleted|isDeleted/i.test(
+                  field.name,
+                ),
+            );
+
+            if (hasSoftDeleteCapableColumn) {
+              errors.push({
+                expected: `Soft delete column to be specified or summary/description to not mention soft delete`,
+                value: "null",
+                description: `Mismatch: Operation mentions soft delete but soft_delete_column is not specified, while model has soft-delete capable columns`,
+                path: `$input.content[${index}].soft_delete_column`,
+              });
+            } else {
+              errors.push({
+                expected: `Summary/description to not mention soft delete when model lacks soft-delete capability`,
+                value: `${op.summary || ""} ${op.description || ""}`,
+                description: `Mismatch: Operation mentions soft delete but model '${op.model_name}' has no soft-delete capable columns`,
+                path: `$input.content[${index}].summary || $input.content[${index}].description`,
+              });
+            }
+          } else {
+            // If soft_delete_column is specified, check if it exists in the model
+            const column = model?.plainFields.find(
+              (el) => el.name === op.soft_delete_column,
+            );
+
+            if (!column) {
+              errors.push({
+                expected: `Field '${op.soft_delete_column}' to exist in model or operation to not mention soft delete`,
+                value: "undefined",
+                description: `Mismatch: Either the field '${op.soft_delete_column}' should exist in model '${op.model_name}', or the operation should not mention soft delete`,
+                path: `$input.content[${index}].soft_delete_column || $input.content[${index}].summary || $input.content[${index}].description`,
+              });
+            }
+          }
+        }
+
+        // Also check if soft_delete_column is specified without mentioning soft delete
+        if (op.soft_delete_column && !mentionsSoftDelete) {
+          errors.push({
+            expected: `Consistency between soft_delete_column and operation description`,
+            value: `soft_delete_column: ${op.soft_delete_column}`,
+            description: `Mismatch: soft_delete_column is specified but soft delete is not mentioned in summary/description`,
+            path: `$input.content[${index}]`,
+          });
+        }
+      }
+    });
+
+    // not implemented
+    if (errors.length !== 0) {
+      console.log(JSON.stringify(errors, null, 2));
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    }
+    return result;
+  };
+
   const application: ILlmApplication<Model> = collection[
     props.model === "chatgpt" ? "chatgpt" : "claude"
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -90,12 +186,26 @@ function createReviewController<Model extends ILlmSchema.Model>(props: {
 }
 
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceOperationsReviewApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeInterfaceOperationsReviewApplication,
-    "claude"
-  >(),
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeInterfaceOperationsReviewApplication,
+      "chatgpt"
+    >({
+      validate: {
+        reviewOperations: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeInterfaceOperationsReviewApplication,
+      "claude"
+    >({
+      validate: {
+        reviewOperations: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps>;

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -4,14 +4,17 @@ import {
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
 import typia, { tags } from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceSchemaHistories } from "./histories/transformInterfaceSchemaHistories";
 import { orchestrateInterfaceSchemasReview } from "./orchestrateInterfaceSchemasReview";
 import { IAutoBeInterfaceSchemaApplication } from "./structures/IAutoBeInterfaceSchemaApplication";
@@ -50,10 +53,17 @@ export async function orchestrateInterfaceSchemas<
           IAuthorizationToken: authTokenSchema,
         }
       : {};
-  for (const y of await Promise.all(
-    matrix.map(async (it) => {
+  for (const y of await executeCachedBatch(
+    matrix.map((it) => async (promptCacheKey) => {
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(ctx, operations, it, 3, progress);
+        await divideAndConquer(
+          ctx,
+          operations,
+          it,
+          3,
+          progress,
+          promptCacheKey,
+        );
       const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
         await orchestrateInterfaceSchemasReview(
           ctx,
@@ -76,13 +86,21 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
   typeNames: string[],
   retry: number,
   progress: AutoBeProgressEventBase,
+  promptCacheKey: string,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const remained: Set<string> = new Set(typeNames);
   const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (let i: number = 0; i < retry; ++i) {
     if (remained.size === 0) break;
     const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-      await process(ctx, operations, schemas, remained, progress);
+      await process(
+        ctx,
+        operations,
+        schemas,
+        remained,
+        progress,
+        promptCacheKey,
+      );
     for (const key of Object.keys(newbie)) {
       schemas[key] = newbie[key];
       remained.delete(key);
@@ -97,6 +115,7 @@ async function process<Model extends ILlmSchema.Model>(
   oldbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
   remained: Set<string>,
   progress: AutoBeProgressEventBase,
+  promptCacheKey: string,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const already: string[] = Object.keys(oldbie);
   const pointer: IPointer<Record<
@@ -117,25 +136,29 @@ async function process<Model extends ILlmSchema.Model>(
       pointer,
     }),
     enforceFunctionCall: true,
-    message: [
-      "Make type components please.",
-      "",
-      "Here is the list of request/response bodies' type names from",
-      "OpenAPI operations. Make type components of them. If more object",
-      "types are required during making the components, please make them",
-      "too.",
-      "",
-      ...Array.from(remained).map((k) => `- \`${k}\``),
-      ...(already.length !== 0
-        ? [
-            "",
-            "> By the way, here is the list of components schemas what you've",
-            "> already made. So, you don't need to make them again.",
-            ">",
-            ...already.map((k) => `> - \`${k}\``),
-          ]
-        : []),
-    ].join("\n"),
+    promptCacheKey,
+    message: StringUtil.trim`
+      Make type components please.
+
+      Here is the list of request/response bodies' type names from
+      OpenAPI operations. Make type components of them. If more object
+      types are required during making the components, please make them
+      too.
+
+      ${Array.from(remained)
+        .map((k) => `      - \`${k}\``)
+        .join("\n")}${
+        already.length !== 0
+          ? StringUtil.trim`
+
+            > By the way, here is the list of components schemas what you've
+            > already made. So, you don't need to make them again.
+            >
+            ${already.map((k) => `> - \`${k}\``).join("\n")}
+          `
+          : ""
+      }
+    `,
   });
   if (pointer.value === null) throw new Error("Failed to create components.");
 
@@ -147,6 +170,7 @@ async function process<Model extends ILlmSchema.Model>(
     ).schemas ?? {};
   ctx.dispatch({
     type: "interfaceSchemas",
+    id: v7(),
     schemas,
     tokenUsage,
     completed: (progress.completed += Object.keys(schemas).length),

package/src/orchestrate/interface/orchestrateInterfaceSchemasReview.ts

@@ -2,11 +2,13 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeInterfaceSchemasReviewEvent,
   AutoBeOpenApi,
+  AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
@@ -23,7 +25,7 @@ export async function orchestrateInterfaceSchemasReview<
     string,
     AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
   >,
-  progress: { total: number; completed: number },
+  progress: AutoBeProgressEventBase,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   try {
     const pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null> =
@@ -35,6 +37,7 @@ export async function orchestrateInterfaceSchemasReview<
       controller: createController({
         model: ctx.model,
         pointer,
+        operations,
         schemas,
       }),
       histories: transformInterfaceSchemasReviewHistories(
@@ -59,6 +62,7 @@ export async function orchestrateInterfaceSchemasReview<
       ).schemas ?? {};
     ctx.dispatch({
       type: "interfaceSchemasReview",
+      id: v7(),
       schemas: schemas,
       review: pointer.value.review,
       plan: pointer.value.plan,
@@ -80,6 +84,7 @@ export async function orchestrateInterfaceSchemasReview<
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null>;
+  operations: AutoBeOpenApi.IOperation[];
   schemas: Record<
     string,
     AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
@@ -100,14 +105,93 @@ function createController<Model extends ILlmSchema.Model>(props: {
       schemas: result.data.content,
       path: "$input.content",
     });
+
+    Object.entries(result.data.content).forEach(
+      ([tagName, jsonDescriptive]) => {
+        const index: AutoBeOpenApi.IOperation | undefined =
+          props.operations.find(
+            (op) =>
+              op.responseBody?.typeName === tagName &&
+              op.method === "patch" &&
+              op.name === "index",
+          );
+
+        // The index API should return the `IPage<T>` type.
+        if (index) {
+          // First check if the schema has the correct object structure
+          if (
+            !("type" in jsonDescriptive) ||
+            jsonDescriptive.type !== "object"
+          ) {
+            errors.push({
+              path: `$input.content.${tagName}`,
+              expected: `{ type: "object", properties: { ... } }`,
+              value: jsonDescriptive,
+              description: `IPage schema must have type: "object". Found: ${JSON.stringify(jsonDescriptive)}`,
+            });
+          } else if (!("properties" in jsonDescriptive)) {
+            errors.push({
+              path: `$input.content.${tagName}`,
+              expected: `Schema with "properties" field`,
+              value: jsonDescriptive,
+              description: `IPage schema must have a "properties" field containing "pagination" and "data" properties.`,
+            });
+          } else if (
+            typia.is<AutoBeOpenApi.IJsonSchema.IObject>(jsonDescriptive)
+          ) {
+            jsonDescriptive.properties ??= {};
+
+            // Check pagination property
+            const pagination = jsonDescriptive.properties["pagination"];
+            if (!pagination || !("$ref" in pagination)) {
+              errors.push({
+                path: `$input.content.${tagName}.properties.pagination`,
+                expected: `{ $ref: "#/components/schemas/IPage.IPagination" }`,
+                value: pagination,
+                description: `IPage must have a "pagination" property with $ref to IPage.IPagination.`,
+              });
+            }
+
+            // Check data property
+            const data = jsonDescriptive.properties["data"];
+            if (!typia.is<AutoBeOpenApi.IJsonSchema.IArray>(data)) {
+              errors.push({
+                path: `$input.content.${tagName}.properties.data`,
+                expected: `AutoBeOpenApi.IJsonSchema.IArray`,
+                value: data,
+                description: `The 'data' property must be an array for the index operation.`,
+              });
+            } else {
+              // Check if array items have proper type reference (not 'any')
+              const arraySchema: AutoBeOpenApi.IJsonSchema.IArray = data;
+              if (
+                !arraySchema.items ||
+                !("$ref" in arraySchema.items) ||
+                arraySchema.items.$ref === "#/components/schemas/any"
+              ) {
+                errors.push({
+                  path: `$input.content.${tagName}.properties.data.items`,
+                  expected: `Reference to a specific type (e.g., $ref to ISummary type)`,
+                  value: arraySchema.items,
+                  description: `The 'data' array must have a specific item type, not 'any[]'. Use a proper type reference like '{Entity}.ISummary' for paginated results.`,
+                });
+              }
+            }
+          }
+        }
+      },
+    );
+
     if (errors.length !== 0)
       return {
         success: false,
         errors,
         data: next,
       };
+
     return result;
   };
+
   const application: ILlmApplication<Model> = collection[
     props.model === "chatgpt" ? "chatgpt" : "claude"
   ](

package/src/orchestrate/interface/structures/IAutoBeInterfaceEndpointsReviewApplication.ts

@@ -0,0 +1,65 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+/**
+ * Interface for reviewing and refining API endpoints through holistic analysis.
+ * 
+ * This application performs comprehensive review of all endpoints generated
+ * through divide-and-conquer strategy, ensuring consistency, eliminating
+ * redundancy, and preventing over-engineering across the entire API surface.
+ */
+export interface IAutoBeInterfaceEndpointsReviewApplication {
+  /**
+   * Reviews and refines the complete collection of API endpoints.
+   * 
+   * This method consolidates all endpoints generated independently by different
+   * groups and performs holistic review to:
+   * - Ensure naming consistency across all endpoints
+   * - Remove duplicate or overlapping endpoints
+   * - Eliminate over-engineered solutions
+   * - Standardize path structures and HTTP methods
+   * - Verify REST API design principles
+   * 
+   * The review process examines the entire API as a cohesive system rather
+   * than individual endpoints, ensuring the final API is intuitive, maintainable,
+   * and follows best practices.
+   * 
+   * @param next - The review results and refined endpoint collection
+   */
+  reviewEndpoints(
+    next: IAutoBeInterfaceEndpointsReviewApplication.IProps,
+  ): void;
+}
+
+export namespace IAutoBeInterfaceEndpointsReviewApplication {
+  export interface IProps {
+    /**
+     * Comprehensive review analysis of all collected endpoints.
+     * 
+     * Contains detailed findings from the holistic review including:
+     * - Identified inconsistencies in naming conventions
+     * - Duplicate endpoints that serve the same purpose
+     * - Over-engineered solutions that add unnecessary complexity
+     * - Violations of REST API design principles
+     * - Recommendations for improvement and standardization
+     * 
+     * The review provides actionable feedback for creating a clean,
+     * consistent, and maintainable API structure.
+     */
+    review: string;
+
+    /**
+     * Refined collection of API endpoints after review and cleanup.
+     * 
+     * The final optimized set of endpoints after:
+     * - Removing duplicates and redundant endpoints
+     * - Standardizing naming conventions across all paths
+     * - Simplifying over-engineered solutions
+     * - Ensuring consistent REST patterns
+     * - Aligning HTTP methods with their semantic meanings
+     * 
+     * This collection represents the production-ready API structure
+     * that balances functionality with simplicity and maintainability.
+     */
+    endpoints: AutoBeOpenApi.IEndpoint[];
+  }
+}

package/src/orchestrate/interface/structures/IAutoBeInterfaceOperationApplication.ts

@@ -91,6 +91,45 @@ export namespace IAutoBeInterfaceOperationApplication {
       AutoBeOpenApi.IOperation,
       "authorizationRole" | "authorizationType"
     > {
+    /**
+     * Prisma schema models relevant to this operation.
+     *
+     * Contains the complete Prisma schema definitions for all entities involved
+     * in this operation, including their fields, relations, and database
+     * constraints. This enables comprehensive validation and schema-aware
+     * operation design.
+     *
+     * The schema information serves multiple critical purposes:
+     *
+     * - **Field Verification**: Ensures all referenced fields actually exist in
+     *   the database schema and have the correct types
+     * - **Relationship Validation**: Confirms that entity relationships are
+     *   properly defined and can support the operation's data access patterns
+     * - **Soft-Delete Detection**: For DELETE operations, identifies whether
+     *   entities have soft-delete fields (deleted_at, is_deleted, etc.) to
+     *   determine if the operation should perform logical deletion instead of
+     *   physical removal
+     * - **Constraint Awareness**: Understands unique constraints, required
+     *   fields, and default values to generate accurate request/response
+     *   schemas
+     *
+     * Example content might include:
+     *
+     * ```prisma
+     * model User {
+     *   id         String    @id @default(uuid())
+     *   email      String    @unique
+     *   name       String
+     *   deleted_at DateTime? // Indicates soft-delete capability
+     *   posts      Post[]
+     * }
+     * ```
+     *
+     * This schema context ensures operations are fully aligned with the actual
+     * database structure and business logic requirements.
+     */
+    prisma_schemas: string;
+
     /**
      * Authorization roles required to access this API operation.
      *

package/src/orchestrate/interface/structures/IAutoBeInterfaceOperationsReviewApplication.ts

@@ -135,5 +135,86 @@ export namespace IAutoBeInterfaceOperationsReviewApplication {
    * ```
    */
   export interface IOperation
-    extends Omit<AutoBeOpenApi.IOperation, "authorizationType"> {}
+    extends Omit<AutoBeOpenApi.IOperation, "authorizationType"> {
+    /**
+     * Prisma schema models relevant to this operation.
+     *
+     * Contains the complete Prisma schema definitions for all entities involved
+     * in this operation, including their fields, relations, and database
+     * constraints. This enables comprehensive validation and schema-aware
+     * operation design.
+     *
+     * The schema information serves multiple critical purposes:
+     *
+     * - **Field Verification**: Ensures all referenced fields actually exist in
+     *   the database schema and have the correct types
+     * - **Relationship Validation**: Confirms that entity relationships are
+     *   properly defined and can support the operation's data access patterns
+     * - **Soft-Delete Detection**: For DELETE operations, identifies whether
+     *   entities have soft-delete fields (deleted_at, is_deleted, etc.) to
+     *   determine if the operation should perform logical deletion instead of
+     *   physical removal
+     * - **Constraint Awareness**: Understands unique constraints, required
+     *   fields, and default values to generate accurate request/response
+     *   schemas
+     *
+     * Example content might include:
+     *
+     * ```prisma
+     * model User {
+     *   id         String    @id @default(uuid())
+     *   email      String    @unique
+     *   name       String
+     *   deleted_at DateTime? // Indicates soft-delete capability
+     *   posts      Post[]
+     * }
+     * ```
+     *
+     * This schema context ensures operations are fully aligned with the actual
+     * database structure and business logic requirements.
+     */
+    prisma_schemas: string;
+
+    /**
+     * Primary Prisma model name for this operation.
+     *
+     * Identifies the main database table/model that this operation targets.
+     * This must match exactly with the Prisma model name defined in the schema.
+     * When soft deletion is specified, this model name indicates which table
+     * should be soft-deleted.
+     *
+     * For example:
+     * - In a "GET /users/:id" operation, this would be "User"
+     * - In a "POST /articles" operation, this would be "Article"
+     * - In a "DELETE /comments/:id" with soft delete, this specifies the "Comment" model to soft-delete
+     *
+     * This property is essential for:
+     * - Determining the primary entity for CRUD operations
+     * - Identifying which table to apply soft deletion to
+     * - Validating operations against the correct Prisma model
+     * - Generating appropriate database queries and validations
+     */
+    model_name: string;
+
+    /**
+     * Soft delete column name for the Prisma models.
+     *
+     * Specifies the column name used for soft deletion in the database tables
+     * associated with this operation. When set to a non-null value, it indicates
+     * that the related entities support soft deletion through this column
+     * (typically a timestamp field like `deleted_at` or `deletedAt`).
+     *
+     * When null, it means the entities involved in this operation use hard
+     * deletion or don't support deletion at all. This information is crucial
+     * for generating appropriate CRUD operations and ensuring data integrity
+     * policies are correctly implemented.
+     *
+     * Common soft delete patterns:
+     * - `"deleted_at"`: Records deletion timestamp
+     * - `"deletedAt"`: Camel-cased deletion timestamp
+     * - `"is_deleted"`: Boolean flag for deletion status
+     * - `null`: No soft deletion (hard delete only)
+     */
+    soft_delete_column: string | null;
+  }
 }