@autobe/agent 0.16.1 → 0.17.1

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -8,7 +8,6 @@ import {
 } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
 import { ILlmSchema } from "@samchon/openapi";
-import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
@@ -16,75 +15,53 @@ import { orchestratePrismaComponents } from "./orchestratePrismaComponent";
 import { orchestratePrismaCorrect } from "./orchestratePrismaCorrect";
 import { orchestratePrismaSchemas } from "./orchestratePrismaSchemas";
 
-export const orchestratePrisma =
-  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
-  async (
-    props: IAutoBeApplicationProps,
-  ): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
-    const start: Date = new Date();
-    ctx.dispatch({
-      type: "prismaStart",
-      created_at: start.toISOString(),
-      reason: props.reason,
-      step: ctx.state().analyze?.step ?? 0,
-    });
+export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: IAutoBeApplicationProps,
+): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
+  const start: Date = new Date();
+  ctx.dispatch({
+    type: "prismaStart",
+    created_at: start.toISOString(),
+    reason: props.reason,
+    step: ctx.state().analyze?.step ?? 0,
+  });
 
-    // COMPONENTS
-    const components:
-      | AutoBeAssistantMessageHistory
-      | AutoBePrismaComponentsEvent = await orchestratePrismaComponents(ctx);
-    if (components.type === "assistantMessage") {
-      ctx.histories().push(components);
-      ctx.dispatch(components);
-      return components;
-    } else ctx.dispatch(components);
+  // COMPONENTS
+  const components:
+    | AutoBeAssistantMessageHistory
+    | AutoBePrismaComponentsEvent = await orchestratePrismaComponents(ctx);
+  if (components.type === "assistantMessage")
+    return ctx.assistantMessage(components);
+  else ctx.dispatch(components);
 
-    // CONSTRUCT AST DATA
-    const events: AutoBePrismaSchemasEvent[] = await orchestratePrismaSchemas(
-      ctx,
-      components.components,
-    );
+  // CONSTRUCT AST DATA
+  const events: AutoBePrismaSchemasEvent[] = await orchestratePrismaSchemas(
+    ctx,
+    components.components,
+  );
 
-    // VALIDATE
-    const result: IAutoBePrismaValidation = await orchestratePrismaCorrect(
-      ctx,
-      {
-        files: events.map((e) => e.file),
-      },
-    );
+  // VALIDATE
+  const result: IAutoBePrismaValidation = await orchestratePrismaCorrect(ctx, {
+    files: events.map((e) => e.file),
+  });
 
-    // COMPILE
-    const compiler: IAutoBeCompiler = await ctx.compiler();
-    const schemas: Record<string, string> = await compiler.prisma.write(
-      result.data,
-      "postgres",
-    );
+  // COMPILE
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  const schemas: Record<string, string> = await compiler.prisma.write(
+    result.data,
+    "postgres",
+  );
 
-    // PROPAGATE
-    const history: AutoBePrismaHistory = {
-      type: "prisma",
-      id: v4(),
-      created_at: start.toISOString(),
-      completed_at: new Date().toISOString(),
-      reason: props.reason,
-      description: "",
-      result: result,
-      schemas,
-      compiled: await compiler.prisma.compile({
-        files: schemas,
-      }),
-      step: ctx.state().analyze?.step ?? 0,
-    };
-    ctx.state().prisma = history;
-    ctx.histories().push(history);
-    if (history.result.success === true)
-      ctx.dispatch({
-        type: "prismaComplete",
-        application: history.result.data,
-        schemas: history.schemas,
-        compiled: history.compiled,
-        step: ctx.state().analyze?.step ?? 0,
-        created_at: new Date().toISOString(),
-      } satisfies AutoBePrismaCompleteEvent);
-    return history;
-  };
+  // PROPAGATE
+  return ctx.dispatch({
+    type: "prismaComplete",
+    result,
+    schemas,
+    compiled: await compiler.prisma.compile({
+      files: schemas,
+    }),
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  } satisfies AutoBePrismaCompleteEvent);
+};

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -4,7 +4,7 @@ import {
   MicroAgentica,
   MicroAgenticaHistory,
 } from "@agentica/core";
-import { AutoBeAssistantMessageHistory, AutoBePrisma } from "@autobe/interface";
+import { AutoBeAssistantMessageHistory } from "@autobe/interface";
 import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
@@ -13,7 +13,8 @@ import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformPrismaComponentsHistories } from "./transformPrismaComponentsHistories";
+import { transformPrismaComponentsHistories } from "./histories/transformPrismaComponentsHistories";
+import { IAutoBePrismaComponentApplication } from "./structures/IAutoBePrismaComponentApplication";
 
 export async function orchestratePrismaComponents<
   Model extends ILlmSchema.Model,
@@ -22,11 +23,10 @@ export async function orchestratePrismaComponents<
   content: string = "Please extract files and tables from the given documents.",
 ): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent> {
   const start: Date = new Date();
-  const pointer: IPointer<IExtractComponentsProps | null> = {
+  const pointer: IPointer<IAutoBePrismaComponentApplication.IProps | null> = {
     value: null,
   };
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
-
   const agentica: MicroAgentica<Model> = new MicroAgentica({
     model: ctx.model,
     vendor: ctx.vendor,
@@ -41,10 +41,7 @@ export async function orchestratePrismaComponents<
       createApplication({
         model: ctx.model,
         build: (next) => {
-          pointer.value ??= {
-            components: [],
-          };
-          pointer.value.components.push(...next.components);
+          pointer.value = next;
         },
       }),
     ],
@@ -53,7 +50,7 @@ export async function orchestratePrismaComponents<
   const histories: MicroAgenticaHistory<Model>[] = await agentica
     .conversate(content)
     .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
+      const tokenUsage = agentica.getTokenUsage().aggregate;
       ctx.usage().record(tokenUsage, ["prisma"]);
     });
   if (histories.at(-1)?.type === "assistantMessage")
@@ -69,6 +66,9 @@ export async function orchestratePrismaComponents<
   return {
     type: "prismaComponents",
     created_at: start.toISOString(),
+    thinking: pointer.value.thinking,
+    review: pointer.value.review,
+    decision: pointer.value.decision,
     components: pointer.value.components,
     step: ctx.state().analyze?.step ?? 0,
   };
@@ -76,7 +76,7 @@ export async function orchestratePrismaComponents<
 
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (next: IExtractComponentsProps) => void;
+  build: (next: IAutoBePrismaComponentApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
@@ -91,18 +91,18 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
       extractComponents: (next) => {
         props.build(next);
       },
-    } satisfies IApplication,
+    } satisfies IAutoBePrismaComponentApplication,
   };
 }
 
 const claude = typia.llm.application<
-  IApplication,
+  IAutoBePrismaComponentApplication,
   "claude",
   { reference: true }
 >();
 const collection = {
   chatgpt: typia.llm.application<
-    IApplication,
+    IAutoBePrismaComponentApplication,
     "chatgpt",
     { reference: true }
   >(),
@@ -111,71 +111,3 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
-
-interface IApplication {
-  /**
-   * Extracts and organizes database schema files with their corresponding table
-   * definitions.
-   *
-   * Processes Prisma schema files and maps each file to its contained database
-   * tables, enabling structured organization of schemas across multiple files
-   * for large projects.
-   *
-   * @example
-   *   ```typescript
-   *   application.extractFilesAndTables({
-   *     components: [
-   *       {
-   *         filename: "schema-01-users.prisma",
-   *         tables: ["user", "user_profile"]
-   *       },
-   *       {
-   *         filename: "schema-02-articles.prisma",
-   *         tables: ["article", "attachment_file"]
-   *       }
-   *     ]
-   *   });
-   *   ```;
-   *
-   * @param props - Configuration object containing the file-to-table mapping
-   *   structure
-   */
-  extractComponents(props: IExtractComponentsProps): void;
-}
-
-interface IExtractComponentsProps {
-  /**
-   * Maps Prisma schema filenames to their contained database tables.
-   *
-   * **Structure:**
-   *
-   * - Key: Prisma schema filename with .prisma extension
-   * - Value: Array of table names defined in that file
-   *
-   * **Example:**
-   *
-   * ```typescript
-   * {
-   *   {
-   *     filename: "schema-01-users.prisma",
-   *     tables: ["user", "admin", "moderator", "user_profile", "user_settings"]
-   *   },
-   *   {
-   *     filename: "schema-02-articles.prisma",
-   *     tables: ["article", "article_snapshot"]
-   *   },
-   *   {
-   *     filename: "schema-03-comments.prisma",
-   *     tables: ["comment", "comment_like"]
-   *   }
-   * }
-   * ```
-   *
-   * **Notes:**
-   *
-   * - Table names must match exact Prisma model names (case-sensitive)
-   * - Keep mapping synchronized with actual schema files
-   * - Use consistent naming convention for files
-   */
-  components: AutoBePrisma.IComponent[];
-}

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -11,7 +11,8 @@ import typia from "typia";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { enforceToolCall } from "../../utils/enforceToolCall";
-import { transformPrismaCorrectHistories } from "./transformPrismaCorrectHistories";
+import { transformPrismaCorrectHistories } from "./histories/transformPrismaCorrectHistories";
+import { IAutoBePrismaCorrectApplication } from "./structures/IAutoBePrismaCorrectApplication";
 
 export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -57,7 +58,7 @@ async function step<Model extends ILlmSchema.Model>(
     created_at: new Date().toISOString(),
   });
 
-  const pointer: IPointer<IModifyPrismaSchemaFilesProps | null> = {
+  const pointer: IPointer<IAutoBePrismaCorrectApplication.IProps | null> = {
     value: null,
   };
   const agentica: MicroAgentica<Model> = new MicroAgentica({
@@ -87,7 +88,7 @@ async function step<Model extends ILlmSchema.Model>(
       "Resolve the compilation errors in the provided Prisma schema files.",
     )
     .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
+      const tokenUsage = agentica.getTokenUsage().aggregate;
       ctx.usage().record(tokenUsage, ["prisma"]);
     });
   if (pointer.value === null) {
@@ -126,7 +127,7 @@ async function step<Model extends ILlmSchema.Model>(
 
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (next: IModifyPrismaSchemaFilesProps) => void;
+  build: (next: IAutoBePrismaCorrectApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
@@ -140,18 +141,18 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
       correctPrismaSchemaFiles: (next) => {
         props.build(next);
       },
-    } satisfies IApplication,
+    } satisfies IAutoBePrismaCorrectApplication,
   };
 }
 
 const claude = typia.llm.application<
-  IApplication,
+  IAutoBePrismaCorrectApplication,
   "claude",
   { reference: true }
 >();
 const collection = {
   chatgpt: typia.llm.application<
-    IApplication,
+    IAutoBePrismaCorrectApplication,
     "chatgpt",
     { reference: true }
   >(),
@@ -160,144 +161,3 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
-
-interface IApplication {
-  /**
-   * Fixes validation errors in specific AutoBePrisma models while preserving
-   * ALL existing business logic and model descriptions.
-   *
-   * ## Core Rules
-   *
-   * 1. Fix ONLY validation errors in provided models - never remove business
-   *    descriptions
-   * 2. Apply minimal changes to error models only - preserve original design
-   *    intent
-   * 3. Return ONLY corrected models - unchanged models remain in original schema
-   * 4. Maintain referential integrity with unchanged models
-   *
-   * ## Targeted Scope
-   *
-   * - Process ONLY models with validation errors from IError[] array
-   * - Exclude models without errors from processing and output
-   * - Minimize context usage by returning corrected models only
-   * - Preserve unchanged models in their original state
-   *
-   * ## Fix Strategy
-   *
-   * - Resolve validation errors within specific models only
-   * - Fix field duplications, invalid references, and type mismatches
-   * - Update cross-model references without modifying target models
-   * - Ensure naming conventions and index rules compliance in corrected models
-   */
-  correctPrismaSchemaFiles(props: IModifyPrismaSchemaFilesProps): void;
-}
-
-interface IModifyPrismaSchemaFilesProps {
-  /**
-   * Detailed execution plan for fixing `AutoBePrisma` validation errors in
-   * specific models.
-   *
-   * 🎯 Purpose: Enable systematic reasoning and step-by-step error resolution
-   * approach for targeted model validation issues
-   *
-   * 📋 Required Planning Content:
-   *
-   * 1. **Error Scope Analysis**
-   *
-   *    - List all validation errors from IAutoBePrismaValidation.IError[] array
-   *    - Extract unique table names from errors to identify affected models
-   *    - Categorize errors by type (field duplications, references, types, indexes)
-   *    - Identify which models need correction vs. which remain unchanged
-   * 2. **Targeted Fix Strategy**
-   *
-   *    - Focus ONLY on models mentioned in validation errors
-   *    - Outline minimal changes needed for each affected model
-   *    - Plan cross-model reference updates (if any) without modifying non-error
-   *         models
-   *    - Ensure unchanged models maintain valid references to corrected models
-   * 3. **Model-Specific Fix Plan**
-   *
-   *    - Model-by-model modification plan for ONLY affected models
-   *    - Exact field additions, renames, or type corrections required
-   *    - Reference updates within corrected models only
-   *    - Index corrections limited to affected models
-   * 4. **Minimal Scope Validation**
-   *
-   *    - Confirm which models will be included in output (error models only)
-   *    - List models that will remain unchanged in original schema
-   *    - Identify cross-model dependencies without including unchanged models
-   *    - Preserve all business logic within corrected models
-   * 5. **Targeted Impact Assessment**
-   *
-   *    - Potential effects of fixes on unchanged models (reference validation)
-   *    - Verification points for corrected models only
-   *    - Ensure no new validation errors in targeted models
-   *    - Confirm minimal output scope compliance
-   *
-   * 💡 Example Planning Structure:
-   *
-   *     ## Error Scope
-   *     - Target Models: shopping_customers, shopping_orders (2 models only)
-   *     - Unchanged Models: All others remain in original schema
-   *
-   *     ## Targeted Fixes
-   *     - shopping_customers: Remove duplicate 'email' field
-   *     - shopping_orders: Update targetModel reference to 'shopping_customers'
-   *
-   *     ## Output Scope
-   *     - Return: Only shopping_customers and shopping_orders models
-   *     - Preserve: All other models unchanged in original schema
-   *
-   *     ## Cross-Model Impact
-   *     - Verify: shopping_orders still references shopping_customers correctly
-   *     - No changes needed in other models referencing these
-   */
-  planning: string;
-
-  /**
-   * ONLY the specific models that contain validation errors and need
-   * correction.
-   *
-   * 📥 Input Structure:
-   *
-   * - Contains ONLY models mentioned in IAutoBePrismaValidation.IError[] array
-   * - Each model has specific validation errors that need targeted correction
-   * - Models not mentioned in errors are excluded from this input
-   * - Represents minimal scope for error correction
-   *
-   * 🔍 Expected Validation Issues (Model-Specific):
-   *
-   * - Duplicate field/relation names within these specific models
-   * - Invalid foreign key references from these models to other models
-   * - Single foreign key fields in index arrays within these models
-   * - Invalid naming conventions within these specific models
-   * - Type validation errors in fields of these models
-   *
-   * 📝 Model Content Analysis (Targeted Scope):
-   *
-   * - Complete field definitions for each error model only
-   * - Relationships from these models (may reference unchanged models)
-   * - Indexes within these models that need correction
-   * - Business descriptions specific to these models
-   * - Cross-model references that need validation (read-only for targets)
-   *
-   * ⚠️ Processing Notes (Focused Approach):
-   *
-   * - Input contains ONLY models with validation errors
-   * - May reference other models not included in this input
-   * - Cross-model references must be validated but target models won't be
-   *   modified
-   * - Output should return corrected versions of ONLY these input models
-   * - All business logic and descriptions within these models must be preserved
-   * - Corrections must not break references from unchanged models
-   *
-   * 🎯 Correction Scope:
-   *
-   * - Fix validation errors within these specific models
-   * - Update internal model structure (fields, relations, indexes)
-   * - Correct references to external models (without modifying targets)
-   * - Maintain compatibility with unchanged models in the full schema
-   * - Return corrected versions of ONLY these models
-   */
-  models: AutoBePrisma.IModel[];
-}

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -10,7 +10,8 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import { forceRetry } from "../../utils/forceRetry";
-import { transformPrismaSchemaHistories } from "./transformPrismaSchemaHistories";
+import { transformPrismaSchemaHistories } from "./histories/transformPrismaSchemaHistories";
+import { IAutoBePrismaSchemaApplication } from "./structures/IAutoBePrismaSchemaApplication";
 
 export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -27,12 +28,16 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
       const otherComponents: AutoBePrisma.IComponent[] = components.filter(
         (y) => comp !== y,
       );
-      const result: IMakePrismaSchemaFileProps = await forceRetry(() =>
-        process(ctx, targetComponent, otherComponents),
+      const result: IAutoBePrismaSchemaApplication.IProps = await forceRetry(
+        () => process(ctx, targetComponent, otherComponents),
       );
       const event: AutoBePrismaSchemasEvent = {
         type: "prismaSchemas",
         created_at: start.toISOString(),
+        thinking: result.thinking,
+        draft: result.draft,
+        review: result.review,
+        final: result.final,
         file: {
           filename: comp.filename,
           namespace: comp.namespace,
@@ -52,8 +57,8 @@ async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   targetComponent: AutoBePrisma.IComponent,
   otherComponents: AutoBePrisma.IComponent[],
-): Promise<IMakePrismaSchemaFileProps> {
-  const pointer: IPointer<IMakePrismaSchemaFileProps | null> = {
+): Promise<IAutoBePrismaSchemaApplication.IProps> {
+  const pointer: IPointer<IAutoBePrismaSchemaApplication.IProps | null> = {
     value: null,
   };
   const agentica: MicroAgentica<Model> = new MicroAgentica({
@@ -83,7 +88,7 @@ async function process<Model extends ILlmSchema.Model>(
   enforceToolCall(agentica);
 
   await agentica.conversate("Make prisma schema file please").finally(() => {
-    const tokenUsage = agentica.getTokenUsage();
+    const tokenUsage = agentica.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["prisma"]);
   });
   if (pointer.value === null)
@@ -96,7 +101,7 @@ function createApplication<Model extends ILlmSchema.Model>(
   props: {
     targetComponent: AutoBePrisma.IComponent;
     otherComponents: AutoBePrisma.IComponent[];
-    build: (next: IMakePrismaSchemaFileProps) => void;
+    build: (next: IAutoBePrismaSchemaApplication.IProps) => void;
   },
 ): IAgenticaController.IClass<Model> {
   assertSchemaModel(ctx.model);
@@ -171,18 +176,18 @@ function createApplication<Model extends ILlmSchema.Model>(
       makePrismaSchemaFile: (next) => {
         props.build(next);
       },
-    } satisfies IApplication,
+    } satisfies IAutoBePrismaSchemaApplication,
   };
 }
 
 const claude = typia.llm.application<
-  IApplication,
+  IAutoBePrismaSchemaApplication,
   "claude",
   { reference: true }
 >();
 const collection = {
   chatgpt: typia.llm.application<
-    IApplication,
+    IAutoBePrismaSchemaApplication,
     "chatgpt",
     { reference: true }
   >(),
@@ -191,75 +196,3 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
-
-interface IApplication {
-  /**
-   * Generates comprehensive Prisma schema files based on detailed requirements
-   * analysis.
-   *
-   * Creates multiple organized schema files following enterprise patterns
-   * including proper domain separation, relationship modeling, snapshot
-   * patterns, inheritance, materialized views, and comprehensive documentation.
-   * The generated schemas implement best practices for scalability,
-   * maintainability, and data integrity.
-   *
-   * @param props Properties containing the file
-   */
-  makePrismaSchemaFile(props: IMakePrismaSchemaFileProps): void;
-}
-
-interface IMakePrismaSchemaFileProps {
-  /**
-   * STEP 1: First enumeration of tables that must be created
-   *
-   * List all table names that need to be created based on the
-   * `targetComponent.tables`. This should be an exact copy of the
-   * `targetComponent.tables` array.
-   *
-   * Example: ["shopping_goods", "shopping_goods_options"]
-   */
-  tablesToCreate: string[];
-
-  /**
-   * STEP 2: Validation review of the first enumeration
-   *
-   * Compare `tablesToCreate` against `targetComponent.tables` and
-   * `otherComponents[].tables`. Write a review statement that validates:
-   *
-   * - All tables from `targetComponent.tables` are included
-   * - No tables from `otherComponents[].tables` are included
-   * - Additional tables (if any) are for M:N junction relationships or
-   *   domain-specific needs
-   * - No forbidden tables from other domains are included
-   *
-   * Example: "VALIDATION PASSED: All required tables from
-   * `targetComponent.tables` included: shopping_goods, shopping_goods_options.
-   * FORBIDDEN CHECK: No tables from `otherComponents` included
-   * (shopping_customers, shopping_sellers are correctly excluded). Additional
-   * tables: none needed for this domain."
-   */
-  validationReview: string;
-
-  /**
-   * STEP 3: Second enumeration of tables to create
-   *
-   * After validation, re-list the tables that will be created. This should be
-   * identical to `tablesToCreate` if validation passed. This serves as the
-   * final confirmed list before model creation.
-   *
-   * Example: ["shopping_goods", "shopping_goods_options"]
-   */
-  confirmedTables: string[];
-
-  /**
-   * STEP 4: Array of Prisma models (database tables) within the domain
-   *
-   * Create exactly one model for each table in `confirmedTables`. Each model
-   * represents a business entity or concept within the namespace. Models can
-   * reference each other through foreign key relationships.
-   *
-   * The `models` array length must equal `confirmedTables.length`. Each
-   * `model.name` must match an entry in `confirmedTables`.
-   */
-  models: AutoBePrisma.IModel[];
-}