@opensaas/stack-core 0.1.6 → 0.3.0

package/src/hooks/index.ts

@@ -18,24 +18,53 @@ export class ValidationError extends Error {
   }
 }
 
+/**
+ * Database error with field-specific error information
+ * Used for Prisma errors like unique constraint violations
+ */
+export class DatabaseError extends Error {
+  public fieldErrors: Record<string, string>
+  public code?: string
+
+  constructor(message: string, fieldErrors: Record<string, string> = {}, code?: string) {
+    super(message)
+    this.name = 'DatabaseError'
+    this.fieldErrors = fieldErrors
+    this.code = code
+  }
+}
+
 /**
  * Execute resolveInput hook
  * Allows modification of input data before validation
  */
-export async function executeResolveInput<T = Record<string, unknown>>(
-  hooks: Hooks<T> | undefined,
-  args: {
-    operation: 'create' | 'update'
-    resolvedData: Partial<T>
-    item?: T
-    context: AccessContext
-  },
-): Promise<Partial<T>> {
+export async function executeResolveInput<
+  TOutput = Record<string, unknown>,
+  TCreateInput = Record<string, unknown>,
+  TUpdateInput = Record<string, unknown>,
+>(
+  hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
+  args:
+    | {
+        operation: 'create'
+        resolvedData: TCreateInput
+        item?: undefined
+        context: AccessContext
+      }
+    | {
+        operation: 'update'
+        resolvedData: TUpdateInput
+        item?: TOutput
+        context: AccessContext
+      },
+): Promise<TCreateInput | TUpdateInput> {
   if (!hooks?.resolveInput) {
     return args.resolvedData
   }
 
-  const result = await hooks.resolveInput(args)
+  // Type assertion is safe because we've constrained the args type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const result = await hooks.resolveInput(args as any)
   return result
 }
 
@@ -43,12 +72,16 @@ export async function executeResolveInput<T = Record<string, unknown>>(
  * Execute validateInput hook
  * Allows custom validation logic
  */
-export async function executeValidateInput<T = Record<string, unknown>>(
-  hooks: Hooks<T> | undefined,
+export async function executeValidateInput<
+  TOutput = Record<string, unknown>,
+  TCreateInput = Record<string, unknown>,
+  TUpdateInput = Record<string, unknown>,
+>(
+  hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
   args: {
     operation: 'create' | 'update'
-    resolvedData: Partial<T>
-    item?: T
+    resolvedData: TCreateInput | TUpdateInput
+    item?: TOutput
     context: AccessContext
   },
 ): Promise<void> {
@@ -76,11 +109,16 @@ export async function executeValidateInput<T = Record<string, unknown>>(
  * Execute beforeOperation hook
  * Runs before database operation (cannot modify data)
  */
-export async function executeBeforeOperation<T = Record<string, unknown>>(
-  hooks: Hooks<T> | undefined,
+export async function executeBeforeOperation<
+  TOutput = Record<string, unknown>,
+  TCreateInput = Record<string, unknown>,
+  TUpdateInput = Record<string, unknown>,
+>(
+  hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
   args: {
     operation: 'create' | 'update' | 'delete'
-    item?: T
+    resolvedData?: TCreateInput | TUpdateInput
+    item?: TOutput
     context: AccessContext
   },
 ): Promise<void> {
@@ -95,11 +133,16 @@ export async function executeBeforeOperation<T = Record<string, unknown>>(
  * Execute afterOperation hook
  * Runs after database operation
  */
-export async function executeAfterOperation<T = Record<string, unknown>>(
-  hooks: Hooks<T> | undefined,
+export async function executeAfterOperation<
+  TOutput = Record<string, unknown>,
+  TCreateInput = Record<string, unknown>,
+  TUpdateInput = Record<string, unknown>,
+>(
+  hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
   args: {
     operation: 'create' | 'update' | 'delete'
-    item: T
+    resolvedData?: TCreateInput | TUpdateInput
+    item: TOutput
     context: AccessContext
   },
 ): Promise<void> {

package/tests/context.test.ts

@@ -101,7 +101,7 @@ describe('getContext', () => {
       expect(mockPrisma.user.create).toHaveBeenCalledWith({
         data: { name: 'John', email: 'john@example.com' },
       })
-      expect(result).toEqual(mockCreatedUser)
+      expect(result).toEqual({ success: true, data: mockCreatedUser })
     })
 
     it('should update an item', async () => {
@@ -121,7 +121,7 @@ describe('getContext', () => {
 
       expect(mockPrisma.user.findUnique).toHaveBeenCalled()
       expect(mockPrisma.user.update).toHaveBeenCalled()
-      expect(result).toEqual(mockUpdatedUser)
+      expect(result).toEqual({ success: true, data: mockUpdatedUser })
     })
 
     it('should delete an item', async () => {
@@ -139,7 +139,7 @@ describe('getContext', () => {
 
       expect(mockPrisma.user.findUnique).toHaveBeenCalled()
       expect(mockPrisma.user.delete).toHaveBeenCalled()
-      expect(result).toEqual(mockDeletedUser)
+      expect(result).toEqual({ success: true, data: mockDeletedUser })
     })
 
     it('should convert listKey to lowercase for db operations', async () => {
@@ -147,16 +147,17 @@ describe('getContext', () => {
       mockPrisma.post.create.mockResolvedValue(mockCreatedPost)
 
       const context = await getContext(config, mockPrisma, null)
-      await context.serverAction({
+      const result = await context.serverAction({
         listKey: 'Post',
         action: 'create',
         data: { title: 'Test Post' },
       })
 
       expect(mockPrisma.post.create).toHaveBeenCalled()
+      expect(result).toEqual({ success: true, data: mockCreatedPost })
     })
 
-    it('should return null for unknown action', async () => {
+    it('should return error for unknown action', async () => {
       const context = await getContext(config, mockPrisma, null)
       const result = await context.serverAction({
         listKey: 'User',
@@ -164,7 +165,38 @@ describe('getContext', () => {
         data: {},
       })
 
-      expect(result).toBeNull()
+      expect(result).toEqual({ success: false, error: 'Access denied or operation failed' })
+    })
+
+    it('should return error for unknown list', async () => {
+      const context = await getContext(config, mockPrisma, null)
+      const result = await context.serverAction({
+        listKey: 'UnknownList',
+        action: 'create',
+        data: {},
+      })
+
+      expect(result).toEqual({
+        success: false,
+        error: 'List "UnknownList" not found in configuration',
+      })
+    })
+
+    it('should handle database errors', async () => {
+      const dbError = new Error('Database connection failed')
+      mockPrisma.user.create.mockRejectedValue(dbError)
+
+      const context = await getContext(config, mockPrisma, null)
+      const result = await context.serverAction({
+        listKey: 'User',
+        action: 'create',
+        data: { name: 'John', email: 'john@example.com' },
+      })
+
+      expect(result).toMatchObject({
+        success: false,
+        error: 'Database connection failed',
+      })
     })
   })