@opensaas/stack-cli 0.39.2 → 0.41.0

package/dist/generator/types.js

@@ -1,49 +1,34 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { resolveListTimestamps } from './prisma.js';
-/**
- * Map OpenSaas field types to TypeScript types
- */
 function mapFieldTypeToTypeScript(field) {
-    // Relationships are handled separately
     if (field.type === 'relationship') {
         return null;
     }
-    // Use field's own TypeScript type generator if available
     if (field.getTypeScriptType) {
         const result = field.getTypeScriptType();
         return result.type;
     }
-    // Fallback for fields without generator methods
     throw new Error(`Field type "${field.type}" does not implement getTypeScriptType method`);
 }
-/**
- * Check if a field is optional in the type
- */
 function isFieldOptional(field) {
     // Relationships are always nullable
     if (field.type === 'relationship') {
         return true;
     }
-    // Use field's own TypeScript type generator if available
     if (field.getTypeScriptType) {
         const result = field.getTypeScriptType();
         return result.optional;
     }
-    // Fallback: assume optional
     return true;
 }
-/**
- * Get names of virtual fields in a list
- */
 function getVirtualFieldNames(fields) {
     return Object.entries(fields)
         .filter(([_, config]) => config.type === 'virtual')
         .map(([name, _]) => name);
 }
 /**
- * Generate virtual fields type - only contains virtual fields
- * This is intersected with Prisma's GetPayload to add virtual fields to query results
+ * Intersected with Prisma's GetPayload to add virtual fields to query results.
  */
 function generateVirtualFieldsType(listName, fields) {
     const lines = [];
@@ -61,7 +46,6 @@ function generateVirtualFieldsType(listName, fields) {
         const nullability = optional ? ' | null' : '';
         lines.push(`  ${fieldName}: ${tsType}${nullability}`);
     }
-    // If no virtual fields, make it an empty object
     if (virtualFields.length === 0) {
         lines.push('  // No virtual fields defined');
     }
@@ -69,8 +53,7 @@ function generateVirtualFieldsType(listName, fields) {
     return lines.join('\n');
 }
 /**
- * Generate transformed fields type - fields with resultExtension transformations
- * This replaces Prisma's base types with transformed types (e.g., string -> HashedPassword)
+ * Replaces Prisma's base types with transformed types (e.g., string -> HashedPassword).
  */
 function generateTransformedFieldsType(listName, fields) {
     const lines = [];
@@ -87,7 +70,6 @@ function generateTransformedFieldsType(listName, fields) {
             lines.push(`  ${fieldName}: ${fieldConfig.resultExtension.outputType}${nullability}`);
         }
     }
-    // If no transformed fields, make it an empty object
     if (transformedFields.length === 0) {
         lines.push('  // No transformed fields defined');
     }
@@ -95,8 +77,8 @@ function generateTransformedFieldsType(listName, fields) {
     return lines.join('\n');
 }
 /**
- * Generate TypeScript Output type for a model (includes virtual fields)
- * This is kept for backwards compatibility but CustomDB uses Prisma's GetPayload + VirtualFields
+ * Kept for backwards compatibility — `CustomDB` itself uses Prisma's
+ * GetPayload + VirtualFields instead.
  */
 function generateModelOutputType(listName, 
 // ListConfig is generic over per-list TypeInfo; we only read `db`/`fields`, which are
@@ -110,7 +92,6 @@ listConfig, dbConfig, isSingleton) {
     // Keystone 6, so the TypeScript id type is `number` rather than `string`.
     lines.push(isSingleton ? '  id: number' : '  id: string');
     for (const [fieldName, fieldConfig] of Object.entries(fields)) {
-        // Skip virtual fields - they're in VirtualFields type
         if (fieldConfig.type === 'virtual')
             continue;
         if (fieldConfig.type === 'relationship') {
@@ -127,7 +108,7 @@ listConfig, dbConfig, isSingleton) {
         else {
             const tsType = mapFieldTypeToTypeScript(fieldConfig);
             if (!tsType)
-                continue; // Skip if no type returned
+                continue;
             const optional = isFieldOptional(fieldConfig);
             const nullability = optional ? ' | null' : '';
             lines.push(`  ${fieldName}: ${tsType}${nullability}`);
@@ -142,12 +123,9 @@ listConfig, dbConfig, isSingleton) {
     if (timestamps.updatedAt) {
         lines.push('  updatedAt: Date');
     }
-    lines.push('} & ' + listName + 'VirtualFields'); // Include virtual fields
+    lines.push('} & ' + listName + 'VirtualFields');
     return lines.join('\n');
 }
-/**
- * Generate convenience type alias (List = ListOutput)
- */
 function generateModelTypeAlias(listName) {
     return `export type ${listName} = ${listName}Output`;
 }
@@ -194,15 +172,11 @@ function renderScalarInputMember(fieldName, fieldConfig, forCreate, indent) {
     }
     return `${indent}${fieldName}${optional}: ${tsType}${nullability}`;
 }
-/**
- * Generate CreateInput type
- */
 function generateCreateInputType(listName, fields) {
     const lines = [];
     lines.push(`export type ${listName}CreateInput = {`);
     for (const [fieldName, fieldConfig] of Object.entries(fields)) {
-        // Skip virtual fields - they don't accept input in create operations
-        // Virtual fields with resolveInput hooks handle side effects but don't store data
+        // Virtual fields with resolveInput hooks can handle side effects but don't store data.
         if (fieldConfig.virtual) {
             continue;
         }
@@ -220,7 +194,7 @@ function generateCreateInputType(listName, fields) {
             // optionality + `| null` nullability for nullable scalars.
             const member = renderScalarInputMember(fieldName, fieldConfig, true, '  ');
             if (!member)
-                continue; // Skip if no type returned
+                continue;
             lines.push(member);
         }
     }
@@ -358,9 +332,6 @@ function buildWriteInputOverride(prismaBase, fields, forCreate) {
     }
     return `${base} & {\n${members.join('\n')}\n  }`;
 }
-/**
- * Generate UpdateInput type
- */
 function generateUpdateInputType(listName, fields) {
     const lines = [];
     lines.push(`export type ${listName}UpdateInput = {`);
@@ -384,25 +355,16 @@ function generateUpdateInputType(listName, fields) {
             // update (always optional) with `| null` nullability for nullable scalars.
             const member = renderScalarInputMember(fieldName, fieldConfig, false, '  ');
             if (!member)
-                continue; // Skip if no type returned
+                continue;
             lines.push(member);
         }
     }
     lines.push('}');
     return lines.join('\n');
 }
-/**
- * Generate WhereInput type by re-exporting Prisma's native WhereInput
- * This ensures compatibility with all Prisma versions and includes all filter operators
- */
 function generateWhereInputType(listName, _fields) {
-    // Simply re-export Prisma's generated WhereInput type
-    // Prisma already generates comprehensive WhereInput types with all filter operators
     return `export type ${listName}WhereInput = Prisma.${listName}WhereInput`;
 }
-/**
- * Generate hook types that reference Prisma input types
- */
 function generateHookTypes(listName) {
     const lines = [];
     lines.push(`/**`);
@@ -446,10 +408,6 @@ function generateHookTypes(listName) {
     lines.push(`}`);
     return lines.join('\n');
 }
-/**
- * Generate Select type that includes virtual fields
- * Extends Prisma's Select type with virtual field selection support and nested relationship overrides
- */
 function generateSelectType(listName, fields) {
     const virtualFields = getVirtualFieldNames(fields);
     const relationshipFields = Object.entries(fields)
@@ -459,7 +417,6 @@ function generateSelectType(listName, fields) {
         targetList: config.ref.split('.')[0],
     }));
     if (virtualFields.length === 0 && relationshipFields.length === 0) {
-        // No virtual fields and no relationships - just re-export Prisma type
         return `/**
  * Select type for ${listName}
  * No virtual fields defined, uses Prisma's Select type directly
@@ -467,13 +424,11 @@ function generateSelectType(listName, fields) {
 export type ${listName}Select = Prisma.${listName}Select`;
     }
     const lines = [];
-    // Add virtual field properties
     if (virtualFields.length > 0) {
         virtualFields.forEach((name) => {
             lines.push(`  ${name}?: boolean`);
         });
     }
-    // Override relationship properties to use custom DefaultArgs
     if (relationshipFields.length > 0) {
         relationshipFields.forEach(({ name, targetList }) => {
             lines.push(`  ${name}?: boolean | ${targetList}DefaultArgs`);
@@ -508,38 +463,30 @@ ${lines.join('\n')}
 }`;
 }
 /**
- * Generate Include type that includes virtual fields
- * Extends Prisma's Include type with virtual field inclusion support and nested relationship overrides
- * Note: Only generates Include type if the list has relationship fields,
- * since Prisma only generates Include types for models with relations
+ * Only generates an Include type if the list has relationship fields — Prisma
+ * itself only generates Include types for models with relations.
  */
 function generateIncludeType(listName, fields) {
-    // Check if list has any relationship fields
     const relationshipFields = Object.entries(fields)
         .filter(([_, config]) => config.type === 'relationship')
         .map(([name, config]) => ({
         name,
         targetList: config.ref.split('.')[0],
     }));
-    // Prisma only generates Include types for models with relationships
-    // If there are no relationships, don't generate an Include type
     if (relationshipFields.length === 0) {
         return null;
     }
     const virtualFields = getVirtualFieldNames(fields);
     const lines = [];
-    // Add virtual field properties
     if (virtualFields.length > 0) {
         virtualFields.forEach((name) => {
             lines.push(`  ${name}?: boolean`);
         });
     }
-    // Override relationship properties to use custom DefaultArgs
     relationshipFields.forEach(({ name, targetList }) => {
         lines.push(`  ${name}?: boolean | ${targetList}DefaultArgs`);
     });
     if (lines.length === 0) {
-        // No virtual fields - just re-export Prisma type
         return `/**
  * Include type for ${listName}
  * No virtual fields defined, uses Prisma's Include type directly
@@ -567,10 +514,9 @@ ${lines.join('\n')}
 }`;
 }
 /**
- * Generate GetPayload helper type that adds virtual fields support to Prisma's GetPayload
- * This allows users to use Prisma.{ListName}GetPayload<T> pattern with virtual fields
- * Always generated to ensure consistency in CustomDB type signatures
- * Even lists without virtual fields need this to support nested relations with virtual fields
+ * Always generated, even for lists without virtual fields — CustomDB type
+ * signatures stay consistent, and lists without their own virtual fields
+ * still need this to support nested relations that have them.
  */
 function generateGetPayloadType(listName, fields) {
     const virtualFields = getVirtualFieldNames(fields);
@@ -582,7 +528,6 @@ function generateGetPayloadType(listName, fields) {
     // payload: only the assembled logical field (added back via TransformedFields)
     // is exposed. Collect those raw column names for omission. See ADR-0006.
     const multiColumnRawNames = Object.entries(fields).flatMap(([name, config]) => config.getColumnNames ? config.getColumnNames(name) : []);
-    // Get relationship fields to override with custom GetPayload types
     const relationshipFields = Object.entries(fields)
         .filter(([_, config]) => config.type === 'relationship')
         .map(([name, config]) => ({
@@ -591,7 +536,6 @@ function generateGetPayloadType(listName, fields) {
         many: !!config.many,
     }));
     const lines = [];
-    // Build documentation
     lines.push(`/**`);
     if (virtualFields.length > 0 || transformedFieldNames.length > 0) {
         lines.push(` * GetPayload type for ${listName} with virtual and transformed field support`);
@@ -634,11 +578,9 @@ function generateGetPayloadType(listName, fields) {
     else {
         lines.push(`  Prisma.${listName}GetPayload<${prismaT}> &`);
     }
-    // Add transformed fields back
     if (transformedFieldNames.length > 0) {
         lines.push(`  ${listName}TransformedFields &`);
     }
-    // Add relationship fields back with custom GetPayload types
     if (relationshipFields.length > 0) {
         lines.push(`  {`);
         for (const rel of relationshipFields) {
@@ -669,7 +611,6 @@ function generateGetPayloadType(listName, fields) {
         }
         lines.push(`  } &`);
     }
-    // Build the virtual fields conditional type
     if (virtualFields.length > 0) {
         lines.push(`  (`);
         lines.push(`    T extends { select: any }`);
@@ -696,15 +637,10 @@ function generateGetPayloadType(listName, fields) {
         lines.push(`  )`);
     }
     else {
-        // No virtual fields, just use empty object
         lines.push(`  {}`);
     }
     return lines.join('\n');
 }
-/**
- * Generate DefaultArgs type for nested relationship selections
- * This type is used when selecting relationships to enable custom Select/Include types
- */
 function generateDefaultArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     if (hasRelationships) {
@@ -727,9 +663,6 @@ export type ${listName}DefaultArgs = {
 }`;
     }
 }
-/**
- * Generate custom FindUniqueArgs type that uses our extended Select/Include
- */
 function generateFindUniqueArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     if (hasRelationships) {
@@ -752,9 +685,6 @@ export type ${listName}FindUniqueArgs = Omit<Prisma.${listName}FindUniqueArgs, '
 }`;
     }
 }
-/**
- * Generate custom FindManyArgs type that uses our extended Select/Include
- */
 function generateFindManyArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     if (hasRelationships) {
@@ -777,9 +707,6 @@ export type ${listName}FindManyArgs = Omit<Prisma.${listName}FindManyArgs, 'sele
 }`;
     }
 }
-/**
- * Generate custom FindFirstArgs type that uses our extended Select/Include
- */
 function generateFindFirstArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     if (hasRelationships) {
@@ -803,9 +730,8 @@ export type ${listName}FindFirstArgs = Omit<Prisma.${listName}FindFirstArgs, 'se
     }
 }
 /**
- * Generate custom GetArgs type for a singleton list's `get()` method — the same
- * include/query narrowing as FindUniqueArgs, minus `where` (a singleton has no
- * unique selector; there is exactly one row).
+ * The same include/query narrowing as FindUniqueArgs, minus `where` (a
+ * singleton has no unique selector; there is exactly one row).
  */
 function generateGetArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
@@ -829,9 +755,6 @@ export type ${listName}GetArgs = {
 }`;
     }
 }
-/**
- * Generate custom CreateArgs type that uses our extended Select/Include
- */
 function generateCreateArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     // Narrow scalar `data` members to OpenSaaS types so field-level narrowing
@@ -860,9 +783,6 @@ export type ${listName}CreateArgs = Omit<Prisma.${listName}CreateArgs, 'select'
 }`;
     }
 }
-/**
- * Generate custom UpdateArgs type that uses our extended Select/Include
- */
 function generateUpdateArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     // See generateCreateArgsType: narrow scalar `data` members (#599).
@@ -889,9 +809,6 @@ export type ${listName}UpdateArgs = Omit<Prisma.${listName}UpdateArgs, 'select'
 }`;
     }
 }
-/**
- * Generate custom DeleteArgs type that uses our extended Select/Include
- */
 function generateDeleteArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     if (hasRelationships) {
@@ -912,9 +829,6 @@ export type ${listName}DeleteArgs = Omit<Prisma.${listName}DeleteArgs, 'select'>
 }`;
     }
 }
-/**
- * Generate custom CreateManyArgs type that uses our extended Select/Include
- */
 function generateCreateManyArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     // createMany `data` is an array of scalar inputs; narrow each element (#599).
@@ -941,9 +855,6 @@ export type ${listName}CreateManyArgs = {
 }`;
     }
 }
-/**
- * Generate custom UpdateManyArgs type that uses our extended Select/Include
- */
 function generateUpdateManyArgsType(listName, fields) {
     const hasRelationships = Object.values(fields).some((field) => field.type === 'relationship');
     // updateMany `data` is a single partial scalar input; narrow it (#599).
@@ -980,6 +891,10 @@ export type ${listName}UpdateManyArgs = {
  * intersection, combined with the self-referential `Context.sudo(): Context`
  * return type, hit `TS2589: Type instantiation is excessively deep` once a
  * schema grew past ~7-8 lists.
+ *
+ * Every method below is generic over its own `*Args` type, to preserve
+ * Prisma's conditional return type together with the virtual-field-aware
+ * `GetPayload` — `count` is the only exception, since it returns a plain number.
  */
 function generateListCrudInterface(listName, isSingleton) {
     const lines = [];
@@ -987,37 +902,28 @@ function generateListCrudInterface(listName, isSingleton) {
     lines.push(` * Access-controlled CRUD methods for ${listName}, with virtual field support.`);
     lines.push(` */`);
     lines.push(`export interface ${listName}Crud {`);
-    // findUnique - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  findUnique: <T extends ${listName}FindUniqueArgs>(`);
     lines.push(`    args: Prisma.SelectSubset<T, ${listName}FindUniqueArgs>`);
     lines.push(`  ) => Promise<${listName}GetPayload<T> | null>`);
-    // findFirst - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  findFirst: <T extends ${listName}FindFirstArgs>(`);
     lines.push(`    args?: Prisma.SelectSubset<T, ${listName}FindFirstArgs>`);
     lines.push(`  ) => Promise<${listName}GetPayload<T> | null>`);
-    // findMany - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  findMany: <T extends ${listName}FindManyArgs>(`);
     lines.push(`    args?: Prisma.SelectSubset<T, ${listName}FindManyArgs>`);
     lines.push(`  ) => Promise<Array<${listName}GetPayload<T>>>`);
-    // create - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  create: <T extends ${listName}CreateArgs>(`);
     lines.push(`    args: Prisma.SelectSubset<T, ${listName}CreateArgs>`);
     lines.push(`  ) => Promise<${listName}GetPayload<T>>`);
-    // update - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  update: <T extends ${listName}UpdateArgs>(`);
     lines.push(`    args: Prisma.SelectSubset<T, ${listName}UpdateArgs>`);
     lines.push(`  ) => Promise<${listName}GetPayload<T> | null>`);
-    // delete - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  delete: <T extends ${listName}DeleteArgs>(`);
     lines.push(`    args: Prisma.SelectSubset<T, ${listName}DeleteArgs>`);
     lines.push(`  ) => Promise<${listName}GetPayload<T> | null>`);
-    // count - no changes to return type
     lines.push(`  count: (args?: Prisma.${listName}CountArgs) => Promise<number>`);
-    // createMany - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  createMany: <T extends ${listName}CreateManyArgs>(`);
     lines.push(`    args: Prisma.SelectSubset<T, ${listName}CreateManyArgs>`);
     lines.push(`  ) => Promise<Array<${listName}GetPayload<T>>>`);
-    // updateMany - generic to preserve Prisma's conditional return type with custom Args for virtual field support
     lines.push(`  updateMany: <T extends ${listName}UpdateManyArgs>(`);
     lines.push(`    args: Prisma.SelectSubset<T, ${listName}UpdateManyArgs>`);
     lines.push(`  ) => Promise<Array<${listName}GetPayload<T>>>`);
@@ -1043,7 +949,7 @@ function generateListCrudInterface(listName, isSingleton) {
  */
 function generateCustomDBType(config) {
     const lines = [];
-    // Generate list of db keys to omit from AccessControlledDB
+    // db keys to omit from AccessControlledDB before re-adding each list's own {List}Crud.
     const dbKeys = Object.keys(config.lists).map((listName) => {
         const dbKey = listName.charAt(0).toLowerCase() + listName.slice(1);
         return `'${dbKey}'`;
@@ -1082,7 +988,6 @@ function generateCustomDBType(config) {
  */
 function generateContextType(_config) {
     const lines = [];
-    // Generate BaseContext - minimal interface for services that only need db and session
     lines.push('/**');
     lines.push(' * Base context type for services that only need database and session access');
     lines.push(' * Compatible with both AccessContext (from hooks) and Context (from server actions)');
@@ -1093,41 +998,33 @@ function generateContextType(_config) {
     lines.push('  session: TSession');
     lines.push('}');
     lines.push('');
-    // Generate Context - extends BaseContext and adds server action capabilities
     lines.push('/**');
     lines.push(' * Full context type with server action capabilities and virtual field typing');
-    lines.push(' * Extends BaseContext and adds serverAction and sudo methods');
+    lines.push(' * Extends BaseContext and adds serverAction, sudo, and withSession methods');
     lines.push(' * Use this type in server actions and components that need full context capabilities');
     lines.push(' */');
     lines.push('export interface Context<TSession extends OpensaasSession = OpensaasSession> extends BaseContext<TSession> {');
     lines.push('  serverAction: (props: ServerActionProps) => Promise<unknown>');
     lines.push('  sudo: () => Context<TSession>');
+    lines.push('  withSession: (session: TSession | null) => Context<TSession>');
     lines.push('}');
     return lines.join('\n');
 }
-/**
- * Collect TypeScript imports from field configurations
- */
 function collectFieldImports(config) {
     const importsMap = new Map();
-    // Iterate through all lists and fields
     for (const listConfig of Object.values(config.lists)) {
         for (const fieldConfig of Object.values(listConfig.fields)) {
-            // Check if field provides imports
             if (fieldConfig.getTypeScriptImports) {
                 const imports = fieldConfig.getTypeScriptImports();
                 for (const imp of imports) {
                     const existing = importsMap.get(imp.from);
                     if (existing) {
-                        // Merge names into existing import
                         imp.names.forEach((name) => existing.names.add(name));
-                        // If either import is not type-only, make the merged import not type-only
                         if (imp.typeOnly === false) {
                             existing.typeOnly = false;
                         }
                     }
                     else {
-                        // Add new import
                         importsMap.set(imp.from, {
                             names: new Set(imp.names),
                             typeOnly: imp.typeOnly ?? true,
@@ -1137,25 +1034,19 @@ function collectFieldImports(config) {
             }
         }
     }
-    // Convert map to array
     return Array.from(importsMap.entries()).map(([from, { names, typeOnly }]) => ({
         names: Array.from(names).sort(),
         from,
         typeOnly,
     }));
 }
-/**
- * Generate all TypeScript types from config
- */
 export function generateTypes(config) {
     const lines = [];
-    // Add header comment
     lines.push('/**');
     lines.push(' * Generated types from OpenSaas configuration');
     lines.push(' * DO NOT EDIT - This file is automatically generated');
     lines.push(' */');
     lines.push('');
-    // Add necessary imports
     // Use alias for Session to avoid conflicts if user has a list named "Session".
     // Session and AccessContext stay on the public root entry point (Session is the
     // module-augmentation target); the rest are unstable runtime plumbing on /internal.
@@ -1166,7 +1057,6 @@ export function generateTypes(config) {
     // `extensionAlias`. See ADR-0008.
     lines.push("import type { PrismaClient, Prisma } from './prisma-client/client.ts'");
     lines.push("import type { PluginServices } from './plugin-types.ts'");
-    // Add field-specific imports
     const fieldImports = collectFieldImports(config);
     for (const imp of fieldImports) {
         const typePrefix = imp.typeOnly ? 'type ' : '';
@@ -1174,8 +1064,6 @@ export function generateTypes(config) {
         lines.push(`import ${typePrefix}{ ${names} } from '${imp.from}'`);
     }
     lines.push('');
-    // Emit shared utility type used by GetPayload types to strip virtual field keys
-    // from select/include before passing to Prisma's GetPayload (prevents `never` intersection)
     lines.push('// Utility: strips virtual field keys from select/include so Prisma GetPayload never sees them');
     lines.push('type StripVirtualFromArgs<T, VirtualKeys extends string> =');
     lines.push('  T extends { select: infer S extends object }');
@@ -1184,12 +1072,11 @@ export function generateTypes(config) {
     lines.push("      ? Omit<T, 'include'> & { include: Omit<I, VirtualKeys> }");
     lines.push('      : T');
     lines.push('');
-    // Generate types for each list
     for (const [listName, listConfig] of Object.entries(config.lists)) {
-        // Generate VirtualFields type first (needed by Output type and CustomDB)
+        // VirtualFields first — needed by the Output type and CustomDB.
         lines.push(generateVirtualFieldsType(listName, listConfig.fields));
         lines.push('');
-        // Generate TransformedFields type (needed by CustomDB)
+        // TransformedFields — needed by CustomDB.
         lines.push(generateTransformedFieldsType(listName, listConfig.fields));
         lines.push('');
         lines.push(generateModelOutputType(listName, listConfig, config.db, !!listConfig.isSingleton));
@@ -1204,22 +1091,17 @@ export function generateTypes(config) {
         lines.push('');
         lines.push(generateHookTypes(listName));
         lines.push('');
-        // Generate Select and Include types with virtual field support
         lines.push(generateSelectType(listName, listConfig.fields));
         lines.push('');
-        // Only generate Include type if the list has relationships
         const includeType = generateIncludeType(listName, listConfig.fields);
         if (includeType) {
             lines.push(includeType);
             lines.push('');
         }
-        // Generate GetPayload helper type with virtual field support
         lines.push(generateGetPayloadType(listName, listConfig.fields));
         lines.push('');
-        // Generate DefaultArgs type for nested relationship support
         lines.push(generateDefaultArgsType(listName, listConfig.fields));
         lines.push('');
-        // Generate custom Args types with virtual field support
         lines.push(generateFindUniqueArgsType(listName, listConfig.fields));
         lines.push('');
         lines.push(generateFindManyArgsType(listName, listConfig.fields));
@@ -1241,19 +1123,13 @@ export function generateTypes(config) {
         lines.push(generateUpdateManyArgsType(listName, listConfig.fields));
         lines.push('');
     }
-    // Generate CustomDB interface
     lines.push(generateCustomDBType(config));
     lines.push('');
-    // Generate Context type
     lines.push(generateContextType(config));
     return lines.join('\n');
 }
-/**
- * Write TypeScript types to file
- */
 export function writeTypes(config, outputPath) {
     const types = generateTypes(config);
-    // Ensure directory exists
     const dir = path.dirname(outputPath);
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });