@opensaas/stack-core 0.12.1 → 0.14.0

package/src/context/index.ts

@@ -9,7 +9,7 @@ import {
 } from '../access/index.js'
 import {
   executeResolveInput,
-  executeValidateInput,
+  executeValidate,
   executeBeforeOperation,
   executeAfterOperation,
   validateFieldRules,
@@ -27,7 +27,9 @@ import type { FieldConfig } from '../config/types.js'
  */
 async function executeFieldResolveInputHooks(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  data: Record<string, any>,
+  inputData: Record<string, any>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolvedData: Record<string, any>,
   fields: Record<string, FieldConfig>,
   operation: 'create' | 'update',
   context: AccessContext,
@@ -35,11 +37,11 @@ async function executeFieldResolveInputHooks(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   item?: any,
 ): Promise<Record<string, unknown>> {
-  const result = { ...data }
+  let result = { ...resolvedData }
 
-  for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+  for (const [fieldKey, fieldConfig] of Object.entries(fields)) {
     // Skip if field not in data
-    if (!(fieldName in result)) continue
+    if (!(fieldKey in result)) continue
 
     // Skip if no hooks defined
     if (!fieldConfig.hooks?.resolveInput) continue
@@ -49,27 +51,102 @@ async function executeFieldResolveInputHooks(
     // and we're working with runtime values that match those types
 
     const transformedValue = await fieldConfig.hooks.resolveInput({
-      inputValue: result[fieldName],
-      operation,
-      fieldName,
       listKey,
+      fieldKey,
+      operation,
+      inputData,
       item,
+      resolvedData: { ...result }, // Pass a copy to avoid mutation affecting recorded args
       context,
-    })
+    } as Parameters<typeof fieldConfig.hooks.resolveInput>[0])
 
-    result[fieldName] = transformedValue
+    // Create new object with updated field to avoid mutating the passed reference
+    result = { ...result, [fieldKey]: transformedValue }
   }
 
   return result
 }
 
+/**
+ * Execute field-level validate hooks
+ * Allows fields to perform custom validation after resolveInput but before database write
+ */
+async function executeFieldValidateHooks(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  inputData: Record<string, any> | undefined,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolvedData: Record<string, any> | undefined,
+  fields: Record<string, FieldConfig>,
+  operation: 'create' | 'update' | 'delete',
+  context: AccessContext,
+  listKey: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  item?: any,
+): Promise<void> {
+  const errors: string[] = []
+  const fieldErrors: Record<string, string> = {}
+
+  const addValidationError = (fieldKey: string) => (msg: string) => {
+    errors.push(msg)
+    fieldErrors[fieldKey] = msg
+  }
+
+  for (const [fieldKey, fieldConfig] of Object.entries(fields)) {
+    // Support both 'validate' (new) and 'validateInput' (deprecated) for backwards compatibility
+    const validateHook = fieldConfig.hooks?.validate ?? fieldConfig.hooks?.validateInput
+    if (!validateHook) continue
+
+    // Execute field hook
+    // Type assertion is safe here because hooks are typed correctly in field definitions
+    if (operation === 'delete') {
+      await validateHook({
+        listKey,
+        fieldKey,
+        operation: 'delete',
+        item,
+        context,
+        addValidationError: addValidationError(fieldKey),
+      } as Parameters<typeof validateHook>[0])
+    } else if (operation === 'create') {
+      await validateHook({
+        listKey,
+        fieldKey,
+        operation: 'create',
+        inputData,
+        item: undefined,
+        resolvedData,
+        context,
+        addValidationError: addValidationError(fieldKey),
+      } as Parameters<typeof validateHook>[0])
+    } else {
+      // operation === 'update'
+      await validateHook({
+        listKey,
+        fieldKey,
+        operation: 'update',
+        inputData,
+        item,
+        resolvedData,
+        context,
+        addValidationError: addValidationError(fieldKey),
+      } as Parameters<typeof validateHook>[0])
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new ValidationError(errors, fieldErrors)
+  }
+}
+
 /**
  * Execute field-level beforeOperation hooks (side effects only)
  * Allows fields to perform side effects before database write
  */
 async function executeFieldBeforeOperationHooks(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  data: Record<string, any>,
+  inputData: Record<string, any>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolvedData: Record<string, any>,
   fields: Record<string, FieldConfig>,
   operation: 'create' | 'update' | 'delete',
   context: AccessContext,
@@ -77,21 +154,43 @@ async function executeFieldBeforeOperationHooks(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   item?: any,
 ): Promise<void> {
-  for (const [fieldName, fieldConfig] of Object.entries(fields)) {
-    // Skip if field not in data (for create/update) or if no hooks defined
+  for (const [fieldKey, fieldConfig] of Object.entries(fields)) {
+    // Skip if no hooks defined
     if (!fieldConfig.hooks?.beforeOperation) continue
-    if (operation !== 'delete' && !(fieldName in data)) continue
+    // Skip if field not in data (for create/update)
+    if (operation !== 'delete' && !(fieldKey in resolvedData)) continue
 
     // Execute field hook (side effects only, no return value used)
     // Type assertion is safe here because hooks are typed correctly in field definitions
-    await fieldConfig.hooks.beforeOperation({
-      resolvedValue: data[fieldName],
-      operation,
-      fieldName,
-      listKey,
-      item,
-      context,
-    })
+    if (operation === 'delete') {
+      await fieldConfig.hooks.beforeOperation({
+        listKey,
+        fieldKey,
+        operation: 'delete',
+        item,
+        context,
+      } as Parameters<typeof fieldConfig.hooks.beforeOperation>[0])
+    } else if (operation === 'create') {
+      await fieldConfig.hooks.beforeOperation({
+        listKey,
+        fieldKey,
+        operation: 'create',
+        inputData,
+        resolvedData,
+        context,
+      } as Parameters<typeof fieldConfig.hooks.beforeOperation>[0])
+    } else {
+      // operation === 'update'
+      await fieldConfig.hooks.beforeOperation({
+        listKey,
+        fieldKey,
+        operation: 'update',
+        inputData,
+        item,
+        resolvedData,
+        context,
+      } as Parameters<typeof fieldConfig.hooks.beforeOperation>[0])
+    }
   }
 }
 
@@ -102,31 +201,51 @@ async function executeFieldBeforeOperationHooks(
 async function executeFieldAfterOperationHooks(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   item: any,
-  data: Record<string, unknown> | undefined,
+  inputData: Record<string, unknown> | undefined,
+  resolvedData: Record<string, unknown> | undefined,
   fields: Record<string, FieldConfig>,
-  operation: 'create' | 'update' | 'delete' | 'query',
+  operation: 'create' | 'update' | 'delete',
   context: AccessContext,
   listKey: string,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   originalItem?: any,
 ): Promise<void> {
-  for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+  for (const [fieldKey, fieldConfig] of Object.entries(fields)) {
     // Skip if no hooks defined
     if (!fieldConfig.hooks?.afterOperation) continue
 
-    // Get the value from item (for all operations)
-    const value = item?.[fieldName]
-
     // Execute field hook (side effects only, no return value used)
-    await fieldConfig.hooks.afterOperation({
-      value,
-      operation,
-      fieldName,
-      listKey,
-      item,
-      originalItem,
-      context,
-    })
+    if (operation === 'delete') {
+      await fieldConfig.hooks.afterOperation({
+        listKey,
+        fieldKey,
+        operation: 'delete',
+        originalItem,
+        context,
+      } as Parameters<typeof fieldConfig.hooks.afterOperation>[0])
+    } else if (operation === 'create') {
+      await fieldConfig.hooks.afterOperation({
+        listKey,
+        fieldKey,
+        operation: 'create',
+        inputData,
+        item,
+        resolvedData,
+        context,
+      } as Parameters<typeof fieldConfig.hooks.afterOperation>[0])
+    } else {
+      // operation === 'update'
+      await fieldConfig.hooks.afterOperation({
+        listKey,
+        fieldKey,
+        operation: 'update',
+        inputData,
+        originalItem,
+        item,
+        resolvedData,
+        context,
+      } as Parameters<typeof fieldConfig.hooks.afterOperation>[0])
+    }
   }
 }
 
@@ -135,6 +254,49 @@ export type ServerActionProps =
   | { listKey: string; action: 'update'; id: string; data: Record<string, unknown> }
   | { listKey: string; action: 'delete'; id: string }
 
+/**
+ * Check if a list is configured as a singleton
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ListConfig must accept any TypeInfo
+function isSingletonList(listConfig: ListConfig<any>): boolean {
+  return !!listConfig.isSingleton
+}
+
+/**
+ * Check if auto-create is enabled for a singleton list
+ * Defaults to true if not explicitly set to false
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ListConfig must accept any TypeInfo
+function shouldAutoCreate(listConfig: ListConfig<any>): boolean {
+  if (!listConfig.isSingleton) return false
+  if (typeof listConfig.isSingleton === 'boolean') return true
+  return listConfig.isSingleton.autoCreate !== false
+}
+
+/**
+ * Extract default values from field configs
+ * Used to auto-create singleton records with sensible defaults
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ListConfig must accept any TypeInfo
+function getDefaultData(listConfig: ListConfig<any>): Record<string, unknown> {
+  const data: Record<string, unknown> = {}
+
+  for (const [fieldKey, fieldConfig] of Object.entries(listConfig.fields)) {
+    // Skip virtual fields - they're not stored in database
+    if (fieldConfig.virtual) continue
+
+    // Skip system fields (id, createdAt, updatedAt)
+    if (fieldKey === 'id' || fieldKey === 'createdAt' || fieldKey === 'updatedAt') continue
+
+    // Add default value if present
+    if ('defaultValue' in fieldConfig && fieldConfig.defaultValue !== undefined) {
+      data[fieldKey] = fieldConfig.defaultValue
+    }
+  }
+
+  return data
+}
+
 /**
  * Parse Prisma error and convert to user-friendly DatabaseError
  */
@@ -274,14 +436,23 @@ export function getContext<
   for (const [listName, listConfig] of Object.entries(config.lists)) {
     const dbKey = getDbKey(listName)
 
-    db[dbKey] = {
+    // Create base operations
+    const createOp = createCreate(listName, listConfig, prisma, context, config)
+    const operations: Record<string, unknown> = {
       findUnique: createFindUnique(listName, listConfig, prisma, context, config),
       findMany: createFindMany(listName, listConfig, prisma, context, config),
-      create: createCreate(listName, listConfig, prisma, context, config),
+      create: createOp,
       update: createUpdate(listName, listConfig, prisma, context, config),
       delete: createDelete(listName, listConfig, prisma, context),
       count: createCount(listName, listConfig, prisma, context),
     }
+
+    // Add get() method for singleton lists
+    if (isSingletonList(listConfig)) {
+      operations.get = createGet(listName, listConfig, prisma, context, config, createOp)
+    }
+
+    db[dbKey] = operations
   }
 
   // Execute plugin runtime functions and populate context.plugins
@@ -478,17 +649,6 @@ function createFindUnique<TPrisma extends PrismaClientLike>(
       listName,
     )
 
-    // Execute field afterOperation hooks (side effects only)
-    await executeFieldAfterOperationHooks(
-      filtered,
-      undefined,
-      listConfig.fields,
-      'query',
-      context,
-      listName,
-      undefined, // originalItem is undefined for query operations
-    )
-
     return filtered
   }
 }
@@ -510,6 +670,14 @@ function createFindMany<TPrisma extends PrismaClientLike>(
     skip?: number
     include?: Record<string, unknown>
   }) => {
+    // Check singleton constraint (throw error instead of silently returning empty)
+    if (isSingletonList(listConfig)) {
+      throw new ValidationError(
+        [`Cannot use findMany: ${listName} is a singleton list. Use get() instead.`],
+        {},
+      )
+    }
+
     // Check query access (skip if sudo mode)
     let where: Record<string, unknown> | undefined = args?.where
     if (!context._isSudo) {
@@ -573,21 +741,6 @@ function createFindMany<TPrisma extends PrismaClientLike>(
       ),
     )
 
-    // Execute field afterOperation hooks for each item (side effects only)
-    await Promise.all(
-      filtered.map((item) =>
-        executeFieldAfterOperationHooks(
-          item,
-          undefined,
-          listConfig.fields,
-          'query',
-          context,
-          listName,
-          undefined, // originalItem is undefined for query operations
-        ),
-      ),
-    )
-
     return filtered
   }
 }
@@ -604,6 +757,21 @@ function createCreate<TPrisma extends PrismaClientLike>(
   config: OpenSaasConfig,
 ) {
   return async (args: { data: Record<string, unknown> }) => {
+    // 0. Check singleton constraint (enforce even in sudo mode)
+    if (isSingletonList(listConfig)) {
+      // Access Prisma model dynamically - required because model names are generated at runtime
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const model = (prisma as any)[getDbKey(listName)]
+      const existingCount = await model.count()
+
+      if (existingCount > 0) {
+        throw new ValidationError(
+          [`Cannot create: ${listName} is a singleton list with an existing record`],
+          {},
+        )
+      }
+    }
+
     // 1. Check create access (skip if sudo mode)
     if (!context._isSudo) {
       const createAccess = listConfig.access?.operation?.create
@@ -619,7 +787,9 @@ function createCreate<TPrisma extends PrismaClientLike>(
 
     // 2. Execute list-level resolveInput hook
     let resolvedData = await executeResolveInput(listConfig.hooks, {
+      listKey: listName,
       operation: 'create',
+      inputData: args.data,
       resolvedData: args.data,
       item: undefined,
       context,
@@ -627,6 +797,7 @@ function createCreate<TPrisma extends PrismaClientLike>(
 
     // 2.5. Execute field-level resolveInput hooks (e.g., hash passwords)
     resolvedData = await executeFieldResolveInputHooks(
+      args.data,
       resolvedData,
       listConfig.fields,
       'create',
@@ -634,14 +805,26 @@ function createCreate<TPrisma extends PrismaClientLike>(
       listName,
     )
 
-    // 3. Execute validateInput hook
-    await executeValidateInput(listConfig.hooks, {
+    // 3. Execute list-level validate hook
+    await executeValidate(listConfig.hooks, {
+      listKey: listName,
       operation: 'create',
+      inputData: args.data,
       resolvedData,
       item: undefined,
       context,
     })
 
+    // 3.5. Execute field-level validate hooks
+    await executeFieldValidateHooks(
+      args.data,
+      resolvedData,
+      listConfig.fields,
+      'create',
+      context,
+      listName,
+    )
+
     // 4. Field validation (isRequired, length, etc.)
     const validation = validateFieldRules(resolvedData, listConfig.fields, 'create')
     if (validation.errors.length > 0) {
@@ -652,6 +835,7 @@ function createCreate<TPrisma extends PrismaClientLike>(
     const filteredData = await filterWritableFields(resolvedData, listConfig.fields, 'create', {
       session: context.session,
       context: { ...context, _isSudo: context._isSudo },
+      inputData: args.data,
     })
 
     // 5.5. Process nested relationship operations
@@ -664,11 +848,21 @@ function createCreate<TPrisma extends PrismaClientLike>(
     )
 
     // 6. Execute field-level beforeOperation hooks (side effects only)
-    await executeFieldBeforeOperationHooks(data, listConfig.fields, 'create', context, listName)
+    await executeFieldBeforeOperationHooks(
+      args.data,
+      resolvedData,
+      listConfig.fields,
+      'create',
+      context,
+      listName,
+    )
 
     // 7. Execute list-level beforeOperation hook
     await executeBeforeOperation(listConfig.hooks, {
+      listKey: listName,
       operation: 'create',
+      inputData: args.data,
+      resolvedData,
       context,
     })
 
@@ -682,16 +876,19 @@ function createCreate<TPrisma extends PrismaClientLike>(
 
     // 9. Execute list-level afterOperation hook
     await executeAfterOperation(listConfig.hooks, {
+      listKey: listName,
       operation: 'create',
+      inputData: args.data,
       item,
-      originalItem: undefined,
+      resolvedData,
       context,
     })
 
     // 10. Execute field-level afterOperation hooks (side effects only)
     await executeFieldAfterOperationHooks(
       item,
-      data,
+      args.data,
+      resolvedData,
       listConfig.fields,
       'create',
       context,
@@ -768,7 +965,9 @@ function createUpdate<TPrisma extends PrismaClientLike>(
 
     // 3. Execute list-level resolveInput hook
     let resolvedData = await executeResolveInput(listConfig.hooks, {
+      listKey: listName,
       operation: 'update',
+      inputData: args.data,
       resolvedData: args.data,
       item,
       context,
@@ -776,6 +975,7 @@ function createUpdate<TPrisma extends PrismaClientLike>(
 
     // 3.5. Execute field-level resolveInput hooks (e.g., hash passwords)
     resolvedData = await executeFieldResolveInputHooks(
+      args.data,
       resolvedData,
       listConfig.fields,
       'update',
@@ -784,14 +984,27 @@ function createUpdate<TPrisma extends PrismaClientLike>(
       item,
     )
 
-    // 4. Execute validateInput hook
-    await executeValidateInput(listConfig.hooks, {
+    // 4. Execute list-level validate hook
+    await executeValidate(listConfig.hooks, {
+      listKey: listName,
       operation: 'update',
+      inputData: args.data,
       resolvedData,
       item,
       context,
     })
 
+    // 4.5. Execute field-level validate hooks
+    await executeFieldValidateHooks(
+      args.data,
+      resolvedData,
+      listConfig.fields,
+      'update',
+      context,
+      listName,
+      item,
+    )
+
     // 5. Field validation (isRequired, length, etc.)
     const validation = validateFieldRules(resolvedData, listConfig.fields, 'update')
     if (validation.errors.length > 0) {
@@ -803,6 +1016,7 @@ function createUpdate<TPrisma extends PrismaClientLike>(
       session: context.session,
       item,
       context: { ...context, _isSudo: context._isSudo },
+      inputData: args.data,
     })
 
     // 6.5. Process nested relationship operations
@@ -816,7 +1030,8 @@ function createUpdate<TPrisma extends PrismaClientLike>(
 
     // 7. Execute field-level beforeOperation hooks (side effects only)
     await executeFieldBeforeOperationHooks(
-      data,
+      args.data,
+      resolvedData,
       listConfig.fields,
       'update',
       context,
@@ -826,8 +1041,11 @@ function createUpdate<TPrisma extends PrismaClientLike>(
 
     // 8. Execute list-level beforeOperation hook
     await executeBeforeOperation(listConfig.hooks, {
+      listKey: listName,
       operation: 'update',
+      inputData: args.data,
       item,
+      resolvedData,
       context,
     })
 
@@ -839,16 +1057,20 @@ function createUpdate<TPrisma extends PrismaClientLike>(
 
     // 10. Execute list-level afterOperation hook
     await executeAfterOperation(listConfig.hooks, {
+      listKey: listName,
       operation: 'update',
-      item: updated,
+      inputData: args.data,
       originalItem: item, // item is the original item before the update
+      item: updated,
+      resolvedData,
       context,
     })
 
     // 11. Execute field-level afterOperation hooks (side effects only)
     await executeFieldAfterOperationHooks(
       updated,
-      data,
+      args.data,
+      resolvedData,
       listConfig.fields,
       'update',
       context,
@@ -885,6 +1107,11 @@ function createDelete<TPrisma extends PrismaClientLike>(
   context: AccessContext<TPrisma>,
 ) {
   return async (args: { where: { id: string } }) => {
+    // 0. Check singleton constraint (enforce even in sudo mode)
+    if (isSingletonList(listConfig)) {
+      throw new ValidationError([`Cannot delete: ${listName} is a singleton list`], {})
+    }
+
     // 1. Fetch the item to pass to access control and hooks
     // Access Prisma model dynamically - required because model names are generated at runtime
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -922,33 +1149,62 @@ function createDelete<TPrisma extends PrismaClientLike>(
       }
     }
 
-    // 3. Execute field-level beforeOperation hooks (side effects only)
-    await executeFieldBeforeOperationHooks({}, listConfig.fields, 'delete', context, listName, item)
+    // 3. Execute list-level validate hook
+    await executeValidate(listConfig.hooks, {
+      listKey: listName,
+      operation: 'delete',
+      item,
+      context,
+    })
+
+    // 3.5. Execute field-level validate hooks
+    await executeFieldValidateHooks(
+      undefined,
+      undefined,
+      listConfig.fields,
+      'delete',
+      context,
+      listName,
+      item,
+    )
+
+    // 4. Execute field-level beforeOperation hooks (side effects only)
+    await executeFieldBeforeOperationHooks(
+      {},
+      {},
+      listConfig.fields,
+      'delete',
+      context,
+      listName,
+      item,
+    )
 
-    // 4. Execute list-level beforeOperation hook
+    // 5. Execute list-level beforeOperation hook
     await executeBeforeOperation(listConfig.hooks, {
+      listKey: listName,
       operation: 'delete',
       item,
       context,
     })
 
-    // 5. Execute database delete
+    // 6. Execute database delete
     const deleted = await model.delete({
       where: args.where,
     })
 
-    // 6. Execute list-level afterOperation hook
+    // 7. Execute list-level afterOperation hook
     await executeAfterOperation(listConfig.hooks, {
+      listKey: listName,
       operation: 'delete',
-      item: deleted,
       originalItem: item, // item is the original item before deletion
       context,
     })
 
-    // 7. Execute field-level afterOperation hooks (side effects only)
+    // 8. Execute field-level afterOperation hooks (side effects only)
     await executeFieldAfterOperationHooks(
       deleted,
       undefined,
+      undefined,
       listConfig.fields,
       'delete',
       context,
@@ -1003,3 +1259,86 @@ function createCount<TPrisma extends PrismaClientLike>(
     return count
   }
 }
+
+/**
+ * Create get operation for singleton lists
+ * Returns the single record, or auto-creates it if enabled
+ */
+function createGet<TPrisma extends PrismaClientLike>(
+  listName: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ListConfig must accept any TypeInfo
+  listConfig: ListConfig<any>,
+  prisma: TPrisma,
+  context: AccessContext<TPrisma>,
+  config: OpenSaasConfig,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createFn: any,
+) {
+  return async () => {
+    // First try to find the existing record
+    // Access Prisma model dynamically - required because model names are generated at runtime
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const model = (prisma as any)[getDbKey(listName)]
+
+    // Check query access (skip if sudo mode)
+    let where: Record<string, unknown> = {}
+    if (!context._isSudo) {
+      const queryAccess = listConfig.access?.operation?.query
+      const accessResult = await checkAccess(queryAccess, {
+        session: context.session,
+        context,
+      })
+
+      if (accessResult === false) {
+        return null
+      }
+
+      // Merge access filter (for singleton, we don't have a specific where clause)
+      if (accessResult && typeof accessResult === 'object') {
+        where = accessResult
+      }
+    }
+
+    // Build include with access control filters
+    const accessControlledInclude = await buildIncludeWithAccessControl(
+      listConfig.fields,
+      {
+        session: context.session,
+        context,
+      },
+      config,
+    )
+
+    // Try to find the record
+    const item = await model.findFirst({
+      where,
+      include: accessControlledInclude,
+    })
+
+    // If record exists, return it
+    if (item) {
+      // Filter readable fields and apply resolveOutput hooks
+      const filtered = await filterReadableFields(
+        item,
+        listConfig.fields,
+        {
+          session: context.session,
+          context: { ...context, _isSudo: context._isSudo },
+        },
+        config,
+        0,
+        listName,
+      )
+      return filtered
+    }
+
+    // If no record and auto-create is enabled, create it
+    if (shouldAutoCreate(listConfig)) {
+      const defaultData = getDefaultData(listConfig)
+      return await createFn({ data: defaultData })
+    }
+
+    // No record and auto-create is disabled
+    return null
+  }
+}