@opensaas/stack-core 0.1.7 → 0.3.0

package/src/context/index.ts

@@ -14,6 +14,7 @@ import {
   executeAfterOperation,
   validateFieldRules,
   ValidationError,
+  DatabaseError,
 } from '../hooks/index.js'
 import { processNestedOperations } from './nested-operations.js'
 import { getDbKey } from '../lib/case-utils.js'
@@ -130,6 +131,69 @@ export type ServerActionProps =
   | { listKey: string; action: 'create'; data: Record<string, unknown> }
   | { listKey: string; action: 'update'; id: string; data: Record<string, unknown> }
   | { listKey: string; action: 'delete'; id: string }
+
+/**
+ * Parse Prisma error and convert to user-friendly DatabaseError
+ */
+function parsePrismaError(error: unknown, listConfig: ListConfig): Error {
+  // Check if it's a Prisma error
+  if (
+    error &&
+    typeof error === 'object' &&
+    'code' in error &&
+    'meta' in error &&
+    typeof error.code === 'string'
+  ) {
+    const prismaError = error as { code: string; meta?: { target?: string[] }; message?: string }
+
+    // Handle unique constraint violation
+    if (prismaError.code === 'P2002') {
+      const target = prismaError.meta?.target
+      const fieldErrors: Record<string, string> = {}
+
+      if (target && Array.isArray(target)) {
+        // Get field names from the constraint target
+        for (const fieldName of target) {
+          // Get the field config to get a better label
+          const fieldConfig = listConfig.fields[fieldName]
+          const label = fieldName.charAt(0).toUpperCase() + fieldName.slice(1)
+
+          if (fieldConfig) {
+            fieldErrors[fieldName] = `This ${label.toLowerCase()} is already in use`
+          } else {
+            fieldErrors[fieldName] = `This value is already in use`
+          }
+        }
+
+        // Create a user-friendly general message
+        const fieldLabels = target.map((f) => f.charAt(0).toUpperCase() + f.slice(1)).join(', ')
+        return new DatabaseError(
+          `${fieldLabels} must be unique. The value you entered is already in use.`,
+          fieldErrors,
+          prismaError.code,
+        )
+      }
+
+      return new DatabaseError('A record with this value already exists', {}, prismaError.code)
+    }
+
+    // Handle other Prisma errors - return generic message
+    return new DatabaseError(
+      prismaError.message || 'A database error occurred',
+      {},
+      prismaError.code,
+    )
+  }
+
+  // Not a Prisma error, return as-is if it's already an Error
+  if (error instanceof Error) {
+    return error
+  }
+
+  // Unknown error type
+  return new Error('An unknown error occurred')
+}
+
 /**
  * Create an access-controlled context
  *
@@ -144,21 +208,23 @@ export function getContext<
 >(
   config: TConfig,
   prisma: TPrisma,
-  session: Session,
+  session: Session | null,
   storage?: StorageUtils,
   _isSudo: boolean = false,
 ): {
   db: AccessControlledDB<TPrisma>
-  session: Session
+  session: Session | null
   prisma: TPrisma
   storage: StorageUtils
+  plugins: Record<string, unknown>
   serverAction: (props: ServerActionProps) => Promise<unknown>
   _isSudo: boolean
   sudo: () => {
     db: AccessControlledDB<TPrisma>
-    session: Session
+    session: Session | null
     prisma: TPrisma
     storage: StorageUtils
+    plugins: Record<string, unknown>
     serverAction: (props: ServerActionProps) => Promise<unknown>
     sudo: () => unknown
     _isSudo: boolean
@@ -196,6 +262,7 @@ export function getContext<
         )
       },
     },
+    plugins: {}, // Will be populated with plugin runtime services
     _isSudo,
   }
 
@@ -213,29 +280,107 @@ export function getContext<
     }
   }
 
+  // Execute plugin runtime functions and populate context.plugins
+  // Use _plugins (sorted by dependencies) if available, otherwise fall back to plugins array
+  const pluginsToExecute = config._plugins || config.plugins || []
+  for (const plugin of pluginsToExecute) {
+    if (plugin.runtime) {
+      try {
+        context.plugins[plugin.name] = plugin.runtime(context)
+      } catch (error) {
+        console.error(`Error executing runtime for plugin "${plugin.name}":`, error)
+        // Continue with other plugins even if one fails
+      }
+    }
+  }
+
   // Generic server action handler with discriminated union for type safety
-  async function serverAction(props: ServerActionProps): Promise<unknown> {
+  // Returns a result object instead of throwing to work properly in Next.js production
+  async function serverAction(
+    props: ServerActionProps,
+  ): Promise<
+    | { success: true; data: unknown }
+    | { success: false; error: string; fieldErrors?: Record<string, string> }
+  > {
     const dbKey = getDbKey(props.listKey)
+    const listConfig = config.lists[props.listKey]
+
+    if (!listConfig) {
+      return {
+        success: false,
+        error: `List "${props.listKey}" not found in configuration`,
+      }
+    }
+
     const model = db[dbKey] as {
       create: (args: { data: Record<string, unknown> }) => Promise<unknown>
       update: (args: { where: { id: string }; data: Record<string, unknown> }) => Promise<unknown>
       delete: (args: { where: { id: string } }) => Promise<unknown>
     }
 
-    if (props.action === 'create') {
-      return await model.create({ data: props.data })
-    } else if (props.action === 'update') {
-      return await model.update({
-        where: { id: props.id },
-        data: props.data,
-      })
-    } else if (props.action === 'delete') {
-      return await model.delete({
-        where: { id: props.id },
-      })
-    }
+    try {
+      let result: unknown = null
+
+      if (props.action === 'create') {
+        result = await model.create({ data: props.data })
+      } else if (props.action === 'update') {
+        result = await model.update({
+          where: { id: props.id },
+          data: props.data,
+        })
+      } else if (props.action === 'delete') {
+        result = await model.delete({
+          where: { id: props.id },
+        })
+      }
+
+      // Check for access denial (null return from access-controlled operations)
+      if (result === null) {
+        return {
+          success: false,
+          error: 'Access denied or operation failed',
+        }
+      }
 
-    return null
+      return {
+        success: true,
+        data: result,
+      }
+    } catch (error) {
+      // Handle ValidationError (has fieldErrors)
+      if (error instanceof ValidationError) {
+        return {
+          success: false,
+          error: error.message,
+          fieldErrors: error.fieldErrors,
+        }
+      }
+
+      // Handle DatabaseError (has fieldErrors)
+      if (error instanceof DatabaseError) {
+        return {
+          success: false,
+          error: error.message,
+          fieldErrors: error.fieldErrors,
+        }
+      }
+
+      // Parse and convert Prisma errors to user-friendly DatabaseError
+      const dbError = parsePrismaError(error, listConfig)
+      if (dbError instanceof DatabaseError) {
+        return {
+          success: false,
+          error: dbError.message,
+          fieldErrors: dbError.fieldErrors,
+        }
+      }
+
+      // Generic error fallback
+      return {
+        success: false,
+        error: dbError.message,
+      }
+    }
   }
 
   // Sudo function - creates a new context that bypasses access control
@@ -249,6 +394,7 @@ export function getContext<
     session,
     prisma,
     storage: context.storage,
+    plugins: context.plugins,
     serverAction,
     sudo,
     _isSudo,

package/src/fields/index.ts

@@ -59,7 +59,7 @@ export function text(options?: Omit<TextField, 'type'>): TextField {
         return z.union([withMax, z.undefined()])
       }
 
-      return !isRequired ? withMax.optional() : withMax
+      return !isRequired ? withMax.optional().nullable() : withMax
     },
     getPrismaType: () => {
       const validation = options?.validation
@@ -122,7 +122,7 @@ export function integer(options?: Omit<IntegerField, 'type'>): IntegerField {
           : withMin
 
       return !options?.validation?.isRequired || operation === 'update'
-        ? withMax.optional()
+        ? withMax.optional().nullable()
         : withMax
     },
     getPrismaType: () => {
@@ -152,7 +152,7 @@ export function checkbox(options?: Omit<CheckboxField, 'type'>): CheckboxField {
     type: 'checkbox',
     ...options,
     getZodSchema: () => {
-      return z.boolean().optional()
+      return z.boolean().optional().nullable()
     },
     getPrismaType: () => {
       const hasDefault = options?.defaultValue !== undefined
@@ -184,7 +184,7 @@ export function timestamp(options?: Omit<TimestampField, 'type'>): TimestampFiel
     type: 'timestamp',
     ...options,
     getZodSchema: () => {
-      return z.union([z.date(), z.iso.datetime()]).optional()
+      return z.union([z.date(), z.iso.datetime()]).optional().nullable()
     },
     getPrismaType: () => {
       let modifiers = '?'
@@ -347,6 +347,7 @@ export function password(options?: Omit<PasswordField, 'type'>): PasswordField {
             message: `${formatFieldName(fieldName)} must be text`,
           })
           .optional()
+          .nullable()
       }
     },
     getPrismaType: () => {
@@ -386,7 +387,7 @@ export function select(options: Omit<SelectField, 'type'>): SelectField {
       })
 
       if (!options.validation?.isRequired || operation === 'update') {
-        schema = schema.optional()
+        schema = schema.optional().nullable()
       }
 
       return schema
@@ -499,8 +500,8 @@ export function json(options?: Omit<JsonField, 'type'>): JsonField {
         // Required in update mode: can be undefined for partial updates
         return z.union([baseSchema, z.undefined()])
       } else {
-        // Not required: can be undefined
-        return baseSchema.optional()
+        // Not required: can be undefined or null
+        return baseSchema.optional().nullable()
       }
     },
     getPrismaType: () => {

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',
+      })
     })
   })