@autobe/agent 0.30.4 → 0.30.5

package/src/orchestrate/realize/programmers/AutoBeRealizeTransformerProgrammer.ts

@@ -58,6 +58,67 @@ export namespace AutoBeRealizeTransformerProgrammer {
     return Array.from(unique);
   }
 
+  export function getRelationMappingTable(props: {
+    application: AutoBeDatabase.IApplication;
+    model: AutoBeDatabase.IModel;
+  }): Array<{
+    propertyKey: string;
+    targetModel: string;
+    relationType: string;
+    fkColumns: string;
+  }> {
+    const result: Array<{
+      propertyKey: string;
+      targetModel: string;
+      relationType: string;
+      fkColumns: string;
+    }> = [];
+
+    // belongsTo relations (forward FK on this model)
+    for (const f of props.model.foreignFields) {
+      result.push({
+        propertyKey: f.relation.name,
+        targetModel: f.relation.targetModel,
+        relationType: "belongsTo",
+        fkColumns: f.name,
+      });
+    }
+
+    // hasMany/hasOne relations (FK on the other model pointing to this model)
+    for (const file of props.application.files) {
+      for (const om of file.models) {
+        for (const fk of om.foreignFields) {
+          if (fk.relation.targetModel === props.model.name) {
+            result.push({
+              propertyKey: fk.relation.oppositeName,
+              targetModel: om.name,
+              relationType: fk.unique ? "hasOne" : "hasMany",
+              fkColumns: fk.name,
+            });
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  export function formatRelationMappingTable(props: {
+    application: AutoBeDatabase.IApplication;
+    model: AutoBeDatabase.IModel;
+  }): string {
+    const relations = getRelationMappingTable(props);
+    if (relations.length === 0) return "(no relations)";
+    return [
+      "| propertyKey | Target Model | Relation Type | FK Column(s) |",
+      "|---|---|---|---|",
+      ...relations.map(
+        (r) =>
+          `| ${r.propertyKey} | ${r.targetModel} | ${r.relationType} | ${r.fkColumns} |`,
+      ),
+    ].join("\n");
+  }
+
   export function getSelectMappingMetadata(props: {
     application: AutoBeDatabase.IApplication;
     model: AutoBeDatabase.IModel;
@@ -81,24 +142,108 @@ export namespace AutoBeRealizeTransformerProgrammer {
   export function writeTemplate(props: {
     plan: AutoBeRealizeTransformerPlan;
     schema: AutoBeOpenApi.IJsonSchemaDescriptive.IObject;
+    schemas: Record<string, AutoBeOpenApi.IJsonSchema>;
   }): string {
+    const recursive: string | null = getRecursiveProperty({
+      schemas: props.schemas,
+      typeName: props.plan.dtoTypeName,
+    });
+    return recursive !== null
+      ? writeRecursiveTemplate({ ...props, recursiveProperty: recursive })
+      : writeNormalTemplate(props);
+  }
+
+  function writeNormalTemplate(props: {
+    plan: AutoBeRealizeTransformerPlan;
+    schema: AutoBeOpenApi.IJsonSchemaDescriptive.IObject;
+  }): string {
+    const name: string = getName(props.plan.dtoTypeName);
+    const dto: string = props.plan.dtoTypeName;
+    const table: string = props.plan.databaseSchemaName;
+    const properties: string = Object.keys(props.schema.properties)
+      .map((k) => `  ${k}: ...,`)
+      .join("\n");
     return StringUtil.trim`
-      export namespace ${getName(props.plan.dtoTypeName)} {
-        export type Payload = Prisma.${props.plan.databaseSchemaName}GetPayload<ReturnType<typeof select>>;
+      export namespace ${name} {
+        export type Payload = Prisma.${table}GetPayload<ReturnType<typeof select>>;
 
         export function select() {
+          // implicit return type for better type inference
           return {
             ...
-          } satisfies Prisma.${props.plan.databaseSchemaName}FindManyArgs;
+          } satisfies Prisma.${table}FindManyArgs;
+        }
+
+        export async function transform(input: Payload): Promise<${dto}> {
+          return {
+${properties}
+          };
+        }
+      }
+    `;
+  }
+
+  function writeRecursiveTemplate(props: {
+    plan: AutoBeRealizeTransformerPlan;
+    schema: AutoBeOpenApi.IJsonSchemaDescriptive.IObject;
+    recursiveProperty: string;
+  }): string {
+    const name: string = getName(props.plan.dtoTypeName);
+    const dto: string = props.plan.dtoTypeName;
+    const table: string = props.plan.databaseSchemaName;
+    const rp: string = props.recursiveProperty;
+    const fk: string = `${rp}_id`;
+    const properties: string = Object.keys(props.schema.properties)
+      .map((k) =>
+        k === rp
+          ? `  ${k}: input.${fk} ? await cache.get(input.${fk}) : null,`
+          : `  ${k}: ...,`,
+      )
+      .join("\n");
+    return StringUtil.trim`
+      export namespace ${name} {
+        export type Payload = Prisma.${table}GetPayload<ReturnType<typeof select>>;
+
+        export function select() {
+          // implicit return type for better type inference
+          return {
+            select: {
+              ...
+              ${fk}: true,
+              ${rp}: undefined, // DO NOT select recursive relation
+            },
+          } satisfies Prisma.${table}FindManyArgs;
         }
 
-        export async function transform(input: Payload): Promise<${props.plan.dtoTypeName}> {
+        export async function transform(
+          input: Payload,
+          cache: VariadicSingleton<Promise<${dto}>, [string]> = createCache(),
+        ): Promise<${dto}> {
           return {
-${Object.keys(props.schema.properties)
-  .map((k) => `  ${k}: ...,`)
-  .join("\n")}
+${properties}
           };
         }
+
+        export async function transformAll(
+          inputs: Payload[],
+        ): Promise<${dto}[]> {
+          const cache = createCache();
+          return await ArrayUtil.asyncMap(inputs, (x) => transform(x, cache));
+        }
+
+        function createCache() {
+          const cache = new VariadicSingleton(
+            async (id: string): Promise<${dto}> => {
+              const record =
+                await MyGlobal.prisma.${table}.findFirstOrThrow({
+                  ...select(),
+                  where: { id },
+                });
+              return transform(record, cache);
+            },
+          );
+          return cache;
+        }
       }
     `;
   }
@@ -150,6 +295,7 @@ ${Object.keys(props.schema.properties)
     };
   }): IValidation.IError[] {
     const errors: IValidation.IError[] = [];
+    // mapping plans
     validateTransformMappings({
       document: props.document,
       errors,
@@ -162,6 +308,8 @@ ${Object.keys(props.schema.properties)
       plan: props.plan,
       selectMappings: props.selectMappings,
     });
+
+    // validate draft
     validateEmptyCode({
       plan: props.plan,
       content: props.draft,
@@ -175,6 +323,13 @@ ${Object.keys(props.schema.properties)
       path: "$input.request.draft",
       errors,
     });
+    validateSelectReturnType({
+      content: props.draft,
+      path: "$input.request.draft",
+      errors,
+    });
+
+    // validate final
     if (props.revise.final !== null) {
       validateEmptyCode({
         plan: props.plan,
@@ -189,6 +344,11 @@ ${Object.keys(props.schema.properties)
         path: "$input.request.revise.final",
         errors,
       });
+      validateSelectReturnType({
+        content: props.revise.final,
+        path: "$input.request.revise.final",
+        errors,
+      });
     }
     return errors;
   }
@@ -337,6 +497,7 @@ ${Object.keys(props.schema.properties)
     const imports: string[] = [
       `import { Prisma } from "@prisma/sdk";`,
       `import { ArrayUtil } from "@nestia/e2e";`,
+      `import { VariadicSingleton } from "tstl";`,
       `import typia, { tags } from "typia";`,
       "",
       `import { IEntity } from "@ORGANIZATION/PROJECT-api/lib/structures/IEntity";`,
@@ -345,6 +506,7 @@ ${Object.keys(props.schema.properties)
           `import { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
       ),
       "",
+      'import { MyGlobal } from "../MyGlobal";',
       `import { toISOStringSafe } from "../utils/toISOStringSafe";`,
     ];
     return imports;
@@ -366,6 +528,26 @@ ${Object.keys(props.schema.properties)
       });
   }
 
+  function validateSelectReturnType(props: {
+    content: string;
+    path: string;
+    errors: IValidation.IError[];
+  }): void {
+    if (/function\s+select\s*\(\s*\)\s*:/.test(props.content))
+      props.errors.push({
+        path: props.path,
+        expected:
+          "select() must use inferred return type (no explicit annotation).",
+        value: props.content,
+        description: StringUtil.trim`
+          select() has an explicit return type annotation. This widens the
+          literal type and destroys Prisma GetPayload inference, causing
+          cascading type errors. Remove the return type — use satisfies
+          on the return value instead.
+        `,
+      });
+  }
+
   function validateNeighbors(props: {
     plan: AutoBeRealizeTransformerPlan;
     neighbors: AutoBeRealizeTransformerPlan[];
@@ -396,6 +578,27 @@ ${Object.keys(props.schema.properties)
         });
   }
 
+  export function getRecursiveProperty(props: {
+    schemas: Record<string, AutoBeOpenApi.IJsonSchema>;
+    typeName: string;
+  }): string | null {
+    const schema: AutoBeOpenApi.IJsonSchema | undefined =
+      props.schemas[props.typeName];
+    if (schema === undefined || !AutoBeOpenApiTypeChecker.isObject(schema))
+      return null;
+
+    const selfRef: string = `#/components/schemas/${props.typeName}`;
+    const hasSelfRef = (s: AutoBeOpenApi.IJsonSchema): boolean => {
+      if (AutoBeOpenApiTypeChecker.isReference(s)) return s.$ref === selfRef;
+      if (AutoBeOpenApiTypeChecker.isOneOf(s))
+        return s.oneOf.some((sub) => hasSelfRef(sub));
+      return false;
+    };
+    for (const [key, value] of Object.entries(schema.properties))
+      if (value && hasSelfRef(value)) return key;
+    return null;
+  }
+
   export const fixApplication = (props: {
     definition: ILlmApplication;
     application: AutoBeDatabase.IApplication;

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationCorrectApplication.ts

@@ -3,12 +3,7 @@ import { IAutoBeRealizeAuthorizationWriteApplication } from "./IAutoBeRealizeAut
 
 export interface IAutoBeRealizeAuthorizationCorrectApplication {
   /**
-   * Process authentication component correction task or preliminary data
-   * requests.
-   *
-   * Fixes TypeScript compilation errors in authentication components through
-   * systematic error diagnosis. Provides error analysis, solution guidance, and
-   * corrected versions while preserving authentication logic.
+   * Process authentication correction task or preliminary data requests.
    *
    * @param next Request containing either preliminary data request or complete
    *   task
@@ -21,98 +16,49 @@ export namespace IAutoBeRealizeAuthorizationCorrectApplication {
     /**
      * Think before you act.
      *
-     * Before requesting preliminary data or completing your task, reflect on
-     * your current state and explain your reasoning:
-     *
-     * For preliminary requests (getAnalysisSections, getDatabaseSchemas, etc.):
-     *
-     * - What critical information is missing that you don't already have?
-     * - Why do you need it specifically right now?
-     * - Be brief - state the gap, don't list everything you have.
-     *
-     * For completion (complete):
+     * For preliminary requests: what critical information is missing?
      *
-     * - What key assets did you acquire?
-     * - What did you accomplish?
-     * - Why is it sufficient to complete?
-     * - Summarize - don't enumerate every single item.
-     *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * For completion: what did you acquire, what did you accomplish, why is it
+     * sufficient?
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getDatabaseSchemas) or final error correction (complete). When
-     * preliminary returns empty array, that type is removed from the union,
-     * physically preventing repeated calls.
+     * Action to perform. Exhausted preliminary types are removed from the
+     * union, physically preventing repeated calls.
      */
     request: IComplete | IAutoBePreliminaryGetDatabaseSchemas;
   }
 
-  /**
-   * Request to fix authentication component errors.
-   *
-   * Executes targeted error correction to resolve TypeScript compilation issues
-   * in provider, decorator, and payload type. Applies systematic fixes while
-   * preserving all authentication logic and business requirements.
-   */
+  /** Request to fix authentication component compilation errors. */
   export interface IComplete {
-    /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval or actual
-     * task execution. Value "complete" indicates this is the final task
-     * execution request.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
     /**
-     * Step 1: TypeScript compilation error analysis and diagnosis.
-     *
-     * AI identifies and categorizes all compilation errors (type mismatches,
-     * import issues, syntax errors) by component (providers/decorator/payload).
-     * Lists specific error messages with their locations and types for
-     * systematic troubleshooting.
+     * Categorize all compilation errors by component
+     * (provider/decorator/payload) with locations.
      */
     error_analysis: string;
 
-    /**
-     * Step 2: Solution guidance and fix recommendations.
-     *
-     * AI provides clear, actionable instructions on how to resolve each
-     * identified error. Includes specific steps like "add property X to
-     * interface Y", "update import path from A to B", or "change type from C to
-     * D". Focus on guidance rather than generating complete code
-     * implementations.
-     */
+    /** Actionable fix instructions for each identified error. */
     solution_guidance: string;
 
     /**
-     * Authentication Provider function configuration containing the function
-     * name and implementation code. The Provider handles JWT token
-     * verification, role validation, and database queries to authenticate
-     * users.
+     * Authentication Provider function (JWT verification, role validation, DB
+     * queries).
      */
     provider: IAutoBeRealizeAuthorizationWriteApplication.IProvider;
 
     /**
-     * Authentication Decorator configuration containing the decorator name and
-     * implementation code. The Decorator integrates with NestJS parameter
-     * decorators to automatically inject authenticated user data into
-     * Controller methods.
+     * Authentication Decorator (NestJS parameter decorator injecting
+     * authenticated user data).
      */
     decorator: IAutoBeRealizeAuthorizationWriteApplication.IDecorator;
 
     /**
-     * Authentication Payload Type configuration containing the payload type
-     * name and implementation code. The Payload Type is used to define the
-     * structure of the authenticated user data that will be injected into
-     * Controller methods when using the decorator. It serves as the TypeScript
-     * type for the parameter in Controller method signatures.
+     * Authentication Payload Type (TypeScript type for authenticated user data
+     * in Controller methods).
      */
     payload: IAutoBeRealizeAuthorizationWriteApplication.IPayloadType;
   }

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationWriteApplication.ts

@@ -2,14 +2,13 @@ import { CamelCasePattern, PascalCasePattern } from "@autobe/interface";
 
 import { IAutoBePreliminaryGetDatabaseSchemas } from "../../common/structures/IAutoBePreliminaryGetDatabaseSchemas";
 
+/**
+ * Generates authentication components (provider, decorator, payload) for an
+ * actor type.
+ */
 export interface IAutoBeRealizeAuthorizationWriteApplication {
   /**
-   * Process authentication component generation task or preliminary data
-   * requests.
-   *
-   * Generates JWT-based authentication infrastructure (provider, decorator,
-   * payload) for role-based authorization. Integrates with NestJS patterns and
-   * jwtAuthorize utility.
+   * Process authentication generation task or preliminary data requests.
    *
    * @param next Request containing either preliminary data request or complete
    *   task
@@ -22,145 +21,86 @@ export namespace IAutoBeRealizeAuthorizationWriteApplication {
     /**
      * Think before you act.
      *
-     * Before requesting preliminary data or completing your task, reflect on
-     * your current state and explain your reasoning:
-     *
-     * For preliminary requests (getAnalysisSections, getDatabaseSchemas, etc.):
-     *
-     * - What critical information is missing that you don't already have?
-     * - Why do you need it specifically right now?
-     * - Be brief - state the gap, don't list everything you have.
-     *
-     * For completion (complete):
+     * For preliminary requests: what database schemas are missing and why?
      *
-     * - What key assets did you acquire?
-     * - What did you accomplish?
-     * - Why is it sufficient to complete?
-     * - Summarize - don't enumerate every single item.
-     *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * For completion: what schemas did you acquire, what authentication
+     * patterns did you implement, why is it sufficient?
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getDatabaseSchemas) or final authentication generation (complete). When
-     * preliminary returns empty array, that type is removed from the union,
-     * physically preventing repeated calls.
+     * Action to perform. Exhausted preliminary types are removed from the
+     * union, physically preventing repeated calls.
      */
     request: IComplete | IAutoBePreliminaryGetDatabaseSchemas;
   }
 
   /**
-   * Request to generate authentication components.
-   *
-   * Executes authentication generation to create provider function, decorator,
-   * and payload type for the specified role. All components work together to
-   * provide JWT-based authentication and authorization.
+   * Request to generate authentication components (provider, decorator,
+   * payload).
    */
   export interface IComplete {
-    /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval or actual
-     * task execution. Value "complete" indicates this is the final task
-     * execution request.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
     /**
-     * Authentication Provider function configuration containing the function
-     * name and implementation code. The Provider handles JWT token
-     * verification, role validation, and database queries to authenticate
-     * users.
+     * Authentication Provider function (JWT verification, role validation, DB
+     * queries).
      */
     provider: IAutoBeRealizeAuthorizationWriteApplication.IProvider;
 
     /**
-     * Authentication Decorator configuration containing the decorator name and
-     * implementation code. The Decorator integrates with NestJS parameter
-     * decorators to automatically inject authenticated user data into
-     * Controller methods.
+     * Authentication Decorator (NestJS parameter decorator injecting
+     * authenticated user data).
      */
     decorator: IAutoBeRealizeAuthorizationWriteApplication.IDecorator;
 
     /**
-     * Authentication Payload Type configuration containing the payload type
-     * name and implementation code. The Payload Type is used to define the
-     * structure of the authenticated user data that will be injected into
-     * Controller methods when using the decorator. It serves as the TypeScript
-     * type for the parameter in Controller method signatures.
+     * Authentication Payload Type (TypeScript type for authenticated user data
+     * in Controller methods).
      */
     payload: IAutoBeRealizeAuthorizationWriteApplication.IPayloadType;
   }
 
   export interface IProvider {
     /**
-     * The name of the authentication Provider function in {role}Authorize
-     * format (e.g., adminAuthorize, userAuthorize). This function will be
-     * called by the decorator to verify JWT tokens and return authenticated
-     * user information for the specified role.
-     *
-     * DO: Use camelCase naming convention.
+     * Provider function name in {role}Authorize format (e.g., adminAuthorize).
+     * MUST use camelCase.
      */
     name: string & CamelCasePattern;
 
     /**
-     * Complete TypeScript code for the authentication Provider function. Must
-     * include: JWT token verification using jwtAuthorize function, role type
-     * checking against payload.type, database query using
-     * MyGlobal.prisma.{tableName} pattern to verify user existence, and proper
-     * error handling with ForbiddenException and UnauthorizedException. The
-     * function should return the authenticated user payload data.
+     * Complete TypeScript code. MUST include: jwtAuthorize call, role type
+     * check, MyGlobal.prisma.{tableName} query,
+     * ForbiddenException/UnauthorizedException handling.
      */
     content: string;
   }
 
   export interface IDecorator {
     /**
-     * The name of the Decorator to be generated in {Actor}Auth format (e.g.,
-     * AdminAuth, UserAuth). This decorator will be used as a parameter
-     * decorator in Controller methods to automatically authenticate and
-     * authorize users for the specific role, injecting the authenticated user
-     * payload as a method parameter.
-     *
-     * DO: Use PascalCase naming convention.
+     * Decorator name in {Actor}Auth format (e.g., AdminAuth, UserAuth). MUST
+     * use PascalCase.
      */
     name: string & PascalCasePattern;
 
     /**
-     * Complete TypeScript code for the authentication Decorator implementation.
-     * Must include: SwaggerCustomizer integration to add bearer token security
-     * schema to API documentation, createParamDecorator implementation that
-     * calls the corresponding Provider function for authentication, Singleton
-     * pattern using tstl library for efficient decorator instance management,
-     * and proper TypeScript typing for the ParameterDecorator interface.
+     * Complete TypeScript code. MUST include: SwaggerCustomizer integration,
+     * createParamDecorator calling Provider, Singleton pattern via tstl.
      */
     content: string;
   }
 
   export interface IPayloadType {
     /**
-     * The name of the Payload type to be generated in {Actor}Payload format
-     * (e.g., AdminPayload, UserPayload). This type defines the structure of the
-     * authenticated user data that will be injected into Controller methods
-     * when using the decorator.
-     *
-     * DO: Use PascalCase naming convention.
+     * Payload type name in {Actor}Payload format (e.g., AdminPayload,
+     * UserPayload). MUST use PascalCase.
      */
     name: string & PascalCasePattern;
 
     /**
-     * Complete TypeScript code for the Payload type interface in {Actor}Payload
-     * format (e.g., AdminPayload, UserPayload). Must include: id field with
-     * UUID format validation, type field as role discriminator, and proper
-     * typia tags for validation. This interface defines the structure of the
-     * authenticated user data that will be injected into Controller methods
-     * when using the decorator and serves as the TypeScript type for the
-     * parameter in Controller method signatures.
+     * Complete TypeScript code. MUST include: id field with UUID validation,
+     * type field as role discriminator, typia tags.
      */
     content: string;
   }