@opensaas/stack-core 0.12.1 → 0.14.0

package/src/context/nested-operations.ts

@@ -3,7 +3,7 @@ import type { AccessContext } from '../access/types.js'
 import { checkAccess, filterWritableFields, getRelatedListConfig } from '../access/index.js'
 import {
   executeResolveInput,
-  executeValidateInput,
+  executeValidate,
   validateFieldRules,
   ValidationError,
 } from '../hooks/index.js'
@@ -15,7 +15,9 @@ import { getDbKey } from '../lib/case-utils.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,
@@ -23,26 +25,28 @@ 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
 
     // Execute field hook
     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
@@ -83,17 +87,7 @@ async function processNestedCreate(
         }
       }
 
-      // 2. Execute list-level resolveInput hook
-      let resolvedData = await executeResolveInput(relatedListConfig.hooks, {
-        operation: 'create',
-        resolvedData: item,
-        item: undefined,
-        context,
-      })
-
-      // 2.5. Execute field-level resolveInput hooks
-      // We need to get the list name for this related config
-      // Since we don't have it directly, we'll need to find it from the config
+      // 2. Get the list name for this related config
       let relatedListName = ''
       for (const [listKey, listCfg] of Object.entries(config.lists)) {
         if (listCfg === relatedListConfig) {
@@ -102,7 +96,19 @@ async function processNestedCreate(
         }
       }
 
+      // 3. Execute list-level resolveInput hook
+      let resolvedData = await executeResolveInput(relatedListConfig.hooks, {
+        listKey: relatedListName,
+        operation: 'create',
+        inputData: item,
+        resolvedData: item,
+        item: undefined,
+        context,
+      })
+
+      // 4. Execute field-level resolveInput hooks
       resolvedData = await executeFieldResolveInputHooks(
+        item,
         resolvedData,
         relatedListConfig.fields,
         'create',
@@ -110,9 +116,11 @@ async function processNestedCreate(
         relatedListName,
       )
 
-      // 3. Execute validateInput hook
-      await executeValidateInput(relatedListConfig.hooks, {
+      // 5. Execute validate hook
+      await executeValidate(relatedListConfig.hooks, {
+        listKey: relatedListName,
         operation: 'create',
+        inputData: item,
         resolvedData,
         item: undefined,
         context,
@@ -132,6 +140,7 @@ async function processNestedCreate(
         {
           session: context.session,
           context,
+          inputData: item,
         },
       )
 
@@ -257,7 +266,9 @@ async function processNestedUpdate(
       // Execute list-level resolveInput hook
       const updateData = (update as Record<string, unknown>).data as Record<string, unknown>
       let resolvedData = await executeResolveInput(relatedListConfig.hooks, {
+        listKey: relatedListName,
         operation: 'update',
+        inputData: updateData,
         resolvedData: updateData,
         item,
         context,
@@ -265,6 +276,7 @@ async function processNestedUpdate(
 
       // Execute field-level resolveInput hooks
       resolvedData = await executeFieldResolveInputHooks(
+        updateData,
         resolvedData,
         relatedListConfig.fields,
         'update',
@@ -273,9 +285,11 @@ async function processNestedUpdate(
         item,
       )
 
-      // Execute validateInput hook
-      await executeValidateInput(relatedListConfig.hooks, {
+      // Execute validate hook
+      await executeValidate(relatedListConfig.hooks, {
+        listKey: relatedListName,
         operation: 'update',
+        inputData: updateData,
         resolvedData,
         item,
         context,
@@ -296,6 +310,7 @@ async function processNestedUpdate(
           session: context.session,
           item,
           context,
+          inputData: updateData,
         },
       )
 

package/src/hooks/index.ts

@@ -46,13 +46,17 @@ export async function executeResolveInput<
   hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
   args:
     | {
+        listKey: string
         operation: 'create'
+        inputData: TCreateInput
         resolvedData: TCreateInput
         item: undefined
         context: AccessContext
       }
     | {
+        listKey: string
         operation: 'update'
+        inputData: TUpdateInput
         resolvedData: TUpdateInput
         item: TOutput
         context: AccessContext
@@ -67,10 +71,10 @@ export async function executeResolveInput<
 }
 
 /**
- * Execute validateInput hook
+ * Execute validate hook (supports both 'validate' and deprecated 'validateInput')
  * Allows custom validation logic
  */
-export async function executeValidateInput<
+export async function executeValidate<
   TOutput = Record<string, unknown>,
   TCreateInput = Record<string, unknown>,
   TUpdateInput = Record<string, unknown>,
@@ -78,19 +82,31 @@ export async function executeValidateInput<
   hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
   args:
     | {
+        listKey: string
         operation: 'create'
+        inputData: TCreateInput
         resolvedData: TCreateInput
         item: undefined
         context: AccessContext
       }
     | {
+        listKey: string
         operation: 'update'
+        inputData: TUpdateInput
         resolvedData: TUpdateInput
         item: TOutput
         context: AccessContext
+      }
+    | {
+        listKey: string
+        operation: 'delete'
+        item: TOutput
+        context: AccessContext
       },
 ): Promise<void> {
-  if (!hooks?.validateInput) {
+  // Support both 'validate' (new) and 'validateInput' (deprecated) for backwards compatibility
+  const validateHook = hooks?.validate || hooks?.validateInput
+  if (!validateHook) {
     return
   }
 
@@ -100,29 +116,50 @@ export async function executeValidateInput<
     errors.push(msg)
   }
 
-  await hooks.validateInput({
+  await validateHook({
     ...args,
     addValidationError,
-  })
+  } as Parameters<typeof validateHook>[0])
 
   if (errors.length > 0) {
     throw new ValidationError(errors)
   }
 }
 
+/**
+ * @deprecated Use executeValidate instead. This alias is provided for backwards compatibility.
+ */
+export const executeValidateInput = executeValidate
+
 /**
  * Execute beforeOperation hook
  * Runs before database operation (cannot modify data)
  */
-export async function executeBeforeOperation<TOutput = Record<string, unknown>>(
-  hooks: Hooks<TOutput> | undefined,
+export async function executeBeforeOperation<
+  TOutput = Record<string, unknown>,
+  TCreateInput = Record<string, unknown>,
+  TUpdateInput = Record<string, unknown>,
+>(
+  hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
   args:
     | {
+        listKey: string
         operation: 'create'
+        inputData: TCreateInput
+        resolvedData: TCreateInput
         context: AccessContext
       }
     | {
-        operation: 'update' | 'delete'
+        listKey: string
+        operation: 'update'
+        inputData: TUpdateInput
+        item: TOutput
+        resolvedData: TUpdateInput
+        context: AccessContext
+      }
+    | {
+        listKey: string
+        operation: 'delete'
         item: TOutput
         context: AccessContext
       },
@@ -131,25 +168,40 @@ export async function executeBeforeOperation<TOutput = Record<string, unknown>>(
     return
   }
 
-  await hooks.beforeOperation(args)
+  await hooks.beforeOperation(args as Parameters<typeof hooks.beforeOperation>[0])
 }
 
 /**
  * Execute afterOperation hook
  * Runs after database operation
  */
-export async function executeAfterOperation<TOutput = Record<string, unknown>>(
-  hooks: Hooks<TOutput> | undefined,
+export async function executeAfterOperation<
+  TOutput = Record<string, unknown>,
+  TCreateInput = Record<string, unknown>,
+  TUpdateInput = Record<string, unknown>,
+>(
+  hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
   args:
     | {
+        listKey: string
         operation: 'create'
+        inputData: TCreateInput
         item: TOutput
-        originalItem: undefined
+        resolvedData: TCreateInput
         context: AccessContext
       }
     | {
-        operation: 'update' | 'delete'
+        listKey: string
+        operation: 'update'
+        inputData: TUpdateInput
+        originalItem: TOutput
         item: TOutput
+        resolvedData: TUpdateInput
+        context: AccessContext
+      }
+    | {
+        listKey: string
+        operation: 'delete'
         originalItem: TOutput
         context: AccessContext
       },
@@ -158,7 +210,7 @@ export async function executeAfterOperation<TOutput = Record<string, unknown>>(
     return
   }
 
-  await hooks.afterOperation(args)
+  await hooks.afterOperation(args as Parameters<typeof hooks.afterOperation>[0])
 }
 
 /**

package/src/index.ts

@@ -38,6 +38,17 @@ export type {
   Plugin,
   PluginContext,
   GeneratedFiles,
+  // List-level hook argument types
+  ResolveInputHookArgs,
+  ValidateHookArgs,
+  BeforeOperationHookArgs,
+  AfterOperationHookArgs,
+  // Field-level hook argument types
+  FieldResolveInputHookArgs,
+  FieldValidateHookArgs,
+  FieldBeforeOperationHookArgs,
+  FieldAfterOperationHookArgs,
+  FieldResolveOutputHookArgs,
 } from './config/index.js'
 
 // Access control

package/tests/access.test.ts

@@ -192,60 +192,57 @@ describe('Access Control', () => {
       expect(result).toBe(true)
     })
 
-    it('should check filter match when operation returns filter', async () => {
-      const item = { userId: '123' }
+    it('should receive inputData for create operations', async () => {
+      const inputData = { title: 'Test', authorId: '123' }
       const fieldAccess: FieldAccess = {
-        read: vi.fn(async () => ({ userId: '123' })),
+        create: vi.fn(async ({ inputData: data }) => {
+          // Field access can validate inputData
+          return data?.authorId === '123'
+        }),
       }
 
-      const result = await checkFieldAccess(fieldAccess, 'read', {
+      const result = await checkFieldAccess(fieldAccess, 'create', {
         session: null,
-        item,
         context: mockContext,
+        inputData,
       })
 
       expect(result).toBe(true)
+      expect(fieldAccess.create).toHaveBeenCalledWith(expect.objectContaining({ inputData }))
     })
 
-    it('should deny access when filter does not match', async () => {
-      const item = { userId: '456' }
-      const fieldAccess: FieldAccess = {
-        read: vi.fn(async () => ({ userId: '123' })),
-      }
-
-      const result = await checkFieldAccess(fieldAccess, 'read', {
-        session: null,
-        item,
-        context: mockContext,
-      })
-
-      expect(result).toBe(false)
-    })
-
-    it('should work with equals condition', async () => {
-      const item = { status: 'active' }
+    it('should receive inputData for update operations', async () => {
+      const inputData = { title: 'Updated', authorId: '123' }
+      const item = { id: '1', authorId: '123' }
       const fieldAccess: FieldAccess = {
-        read: vi.fn(async () => ({ status: { equals: 'active' } })),
+        update: vi.fn(async ({ inputData: data, item: existingItem }) => {
+          // Field access can validate inputData and check existing item
+          return data?.authorId === existingItem?.authorId
+        }),
       }
 
-      const result = await checkFieldAccess(fieldAccess, 'read', {
+      const result = await checkFieldAccess(fieldAccess, 'update', {
         session: null,
         item,
         context: mockContext,
+        inputData,
       })
 
       expect(result).toBe(true)
+      expect(fieldAccess.update).toHaveBeenCalledWith(expect.objectContaining({ inputData, item }))
     })
 
-    it('should work with not condition', async () => {
-      const item = { status: 'active' }
+    it('should not receive inputData for read operations', async () => {
       const fieldAccess: FieldAccess = {
-        read: vi.fn(async () => ({ status: { not: 'deleted' } })),
+        read: vi.fn(async ({ inputData }) => {
+          // inputData should be undefined for read operations
+          expect(inputData).toBeUndefined()
+          return true
+        }),
       }
 
       const result = await checkFieldAccess(fieldAccess, 'read', {
         session: null,
-        item,
         context: mockContext,
       })
 
@@ -487,12 +484,15 @@ describe('Access Control', () => {
         session: { userId: '123' },
         item,
         context: mockContext,
+        inputData: data,
       })
 
       expect(accessFn).toHaveBeenCalledWith({
         session: { userId: '123' },
         item,
         context: mockContext,
+        inputData: data,
+        operation: 'update',
       })
     })
   })

package/tests/config.test.ts

@@ -76,7 +76,7 @@ describe('config helpers', () => {
   })
 
   describe('list', () => {
-    it('should return the same list config', () => {
+    it('should return normalized list config', () => {
       const testList: ListConfig = {
         fields: {
           name: { type: 'text' },
@@ -85,7 +85,9 @@ describe('config helpers', () => {
       }
 
       const result = list(testList)
-      expect(result).toBe(testList)
+      // list() normalizes access control, so it creates a new object
+      expect(result.fields).toEqual(testList.fields)
+      expect(result.access).toBeUndefined()
     })
 
     it('should support text fields', () => {
@@ -161,7 +163,7 @@ describe('config helpers', () => {
       expect(testList.fields.author.type).toBe('relationship')
     })
 
-    it('should support access control', () => {
+    it('should support access control object form', () => {
       const testList = list({
         fields: { name: { type: 'text' } },
         access: {
@@ -177,6 +179,21 @@ describe('config helpers', () => {
       expect(testList.access?.operation).toBeDefined()
     })
 
+    it('should support access control function shorthand', () => {
+      const isAdmin = () => true
+      const testList = list({
+        fields: { name: { type: 'text' } },
+        access: isAdmin,
+      })
+
+      // Function shorthand should be normalized to object form
+      expect(testList.access?.operation).toBeDefined()
+      expect(testList.access?.operation?.query).toBe(isAdmin)
+      expect(testList.access?.operation?.create).toBe(isAdmin)
+      expect(testList.access?.operation?.update).toBe(isAdmin)
+      expect(testList.access?.operation?.delete).toBe(isAdmin)
+    })
+
     it('should support hooks', () => {
       const testList = list({
         fields: { name: { type: 'text' } },

package/tests/nested-access-and-hooks.test.ts

@@ -50,7 +50,10 @@ describe('Nested Operations - Access Control and Hooks', () => {
 
   describe('Nested Create Operations', () => {
     it('should run hooks and access control for nested create', async () => {
-      const userResolveInputHook = vi.fn(async ({ inputValue }) => inputValue?.toUpperCase())
+      const userResolveInputHook = vi.fn(async ({ resolvedData, fieldKey }) => {
+        const value = resolvedData[fieldKey]
+        return typeof value === 'string' ? value.toUpperCase() : value
+      })
       const userListResolveInputHook = vi.fn(async ({ resolvedData }) => resolvedData)
       const userValidateInputHook = vi.fn(async () => {})
       const postResolveInputHook = vi.fn(async ({ resolvedData }) => resolvedData)
@@ -140,9 +143,11 @@ describe('Nested Operations - Access Control and Hooks', () => {
 
       expect(userResolveInputHook).toHaveBeenCalledWith(
         expect.objectContaining({
-          inputValue: 'john',
+          fieldKey: 'name',
           operation: 'create',
-          fieldName: 'name',
+          resolvedData: expect.objectContaining({
+            name: 'john',
+          }),
         }),
       )