@opensaas/stack-core 0.10.0 → 0.12.0

package/src/fields/index.ts

@@ -2,8 +2,10 @@ import { z } from 'zod'
 import type {
   TextField,
   IntegerField,
+  DecimalField,
   CheckboxField,
   TimestampField,
+  CalendarDayField,
   PasswordField,
   SelectField,
   RelationshipField,
@@ -64,16 +66,23 @@ export function text<
 
       return !isRequired ? withMax.optional().nullable() : withMax
     },
-    getPrismaType: () => {
+    getPrismaType: (_fieldName: string) => {
       const validation = options?.validation
+      const db = options?.db
       const isRequired = validation?.isRequired
+      const isNullable = db?.isNullable ?? !isRequired
       let modifiers = ''
 
       // Optional modifier
-      if (!isRequired) {
+      if (isNullable) {
         modifiers += '?'
       }
 
+      // Native type modifier (e.g., @db.Text)
+      if (db?.nativeType) {
+        modifiers += ` @db.${db.nativeType}`
+      }
+
       // Unique/index modifiers
       if (options?.isIndexed === 'unique') {
         modifiers += ' @unique'
@@ -81,6 +90,11 @@ export function text<
         modifiers += ' @index'
       }
 
+      // Map modifier
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
+      }
+
       return {
         type: 'String',
         modifiers: modifiers || undefined,
@@ -130,12 +144,23 @@ export function integer<
         ? withMax.optional().nullable()
         : withMax
     },
-    getPrismaType: () => {
+    getPrismaType: (_fieldName: string) => {
       const isRequired = options?.validation?.isRequired
+      let modifiers = ''
+
+      // Optional modifier
+      if (!isRequired) {
+        modifiers += '?'
+      }
+
+      // Map modifier
+      if (options?.db?.map) {
+        modifiers += ` @map("${options.db.map}")`
+      }
 
       return {
         type: 'Int',
-        modifiers: isRequired ? undefined : '?',
+        modifiers: modifiers || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -149,6 +174,172 @@ export function integer<
   }
 }
 
+/**
+ * Decimal field for precise numeric values (e.g., currency, measurements)
+ *
+ * **Features:**
+ * - Stores decimal numbers with configurable precision and scale
+ * - Uses Prisma's Decimal type (backed by decimal.js for precision)
+ * - Default precision: 18 digits, scale: 4 decimal places
+ * - Validation for min/max values
+ * - Optional database column mapping and nullability control
+ * - Index support (boolean or 'unique')
+ *
+ * **Usage Example:**
+ * ```typescript
+ * // In opensaas.config.ts
+ * fields: {
+ *   price: decimal({
+ *     precision: 10,
+ *     scale: 2,
+ *     validation: {
+ *       isRequired: true,
+ *       min: '0',
+ *       max: '999999.99'
+ *     }
+ *   }),
+ *   coordinates: decimal({
+ *     precision: 18,
+ *     scale: 8,
+ *     db: { map: 'coord_value' }
+ *   })
+ * }
+ *
+ * // Creating with decimal values
+ * const product = await context.db.product.create({
+ *   data: {
+ *     price: '19.99', // Can use string
+ *     // price: 19.99,  // or number (converted to Decimal)
+ *   }
+ * })
+ * ```
+ *
+ * @param options - Field configuration options
+ * @returns Decimal field configuration
+ */
+export function decimal<
+  TTypeInfo extends import('../config/types.js').TypeInfo = import('../config/types.js').TypeInfo,
+>(options?: Omit<DecimalField<TTypeInfo>, 'type'>): DecimalField<TTypeInfo> {
+  const precision = options?.precision ?? 18
+  const scale = options?.scale ?? 4
+
+  return {
+    type: 'decimal',
+    precision,
+    scale,
+    ...options,
+    getZodSchema: (fieldName: string, operation: 'create' | 'update') => {
+      // Decimal values can be provided as strings or numbers
+      // Prisma will convert them to Decimal instances
+      const baseSchema = z.union(
+        [
+          z.string({
+            message: `${formatFieldName(fieldName)} must be a decimal value (string or number)`,
+          }),
+          z.number({
+            message: `${formatFieldName(fieldName)} must be a decimal value (string or number)`,
+          }),
+        ],
+        {
+          message: `${formatFieldName(fieldName)} must be a decimal value`,
+        },
+      )
+
+      let schema = baseSchema
+
+      // Add min validation if specified
+      if (options?.validation?.min !== undefined) {
+        const minValue = parseFloat(options.validation.min)
+        schema = schema.refine(
+          (val) => {
+            const numVal = typeof val === 'string' ? parseFloat(val) : val
+            return !isNaN(numVal) && numVal >= minValue
+          },
+          {
+            message: `${formatFieldName(fieldName)} must be at least ${options.validation.min}`,
+          },
+        )
+      }
+
+      // Add max validation if specified
+      if (options?.validation?.max !== undefined) {
+        const maxValue = parseFloat(options.validation.max)
+        schema = schema.refine(
+          (val) => {
+            const numVal = typeof val === 'string' ? parseFloat(val) : val
+            return !isNaN(numVal) && numVal <= maxValue
+          },
+          {
+            message: `${formatFieldName(fieldName)} must be at most ${options.validation.max}`,
+          },
+        )
+      }
+
+      return !options?.validation?.isRequired || operation === 'update'
+        ? schema.optional().nullable()
+        : schema
+    },
+    getPrismaType: (_fieldName: string) => {
+      const validation = options?.validation
+      const db = options?.db
+      const isRequired = validation?.isRequired
+      const isNullable = db?.isNullable ?? !isRequired
+
+      let modifiers = ''
+
+      // Optional modifier
+      if (isNullable) {
+        modifiers += '?'
+      }
+
+      // Precision and scale
+      modifiers += ` @db.Decimal(${precision}, ${scale})`
+
+      // Default value if provided
+      if (options?.defaultValue !== undefined) {
+        modifiers += ` @default(${options.defaultValue})`
+      }
+
+      // Database mapping
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
+      }
+
+      // Unique/index modifiers
+      if (options?.isIndexed === 'unique') {
+        modifiers += ' @unique'
+      } else if (options?.isIndexed === true) {
+        modifiers += ' @index'
+      }
+
+      return {
+        type: 'Decimal',
+        modifiers: modifiers.trimStart() || undefined,
+      }
+    },
+    getTypeScriptType: () => {
+      const validation = options?.validation
+      const db = options?.db
+      const isRequired = validation?.isRequired
+      const isNullable = db?.isNullable ?? !isRequired
+
+      return {
+        type: "import('decimal.js').Decimal",
+        optional: isNullable,
+      }
+    },
+    getTypeScriptImports: () => {
+      return [
+        {
+          names: ['Decimal'],
+          from: 'decimal.js',
+          typeOnly: true,
+        },
+      ]
+    },
+  }
+}
+
 /**
  * Checkbox (boolean) field
  */
@@ -161,7 +352,7 @@ export function checkbox<
     getZodSchema: () => {
       return z.boolean().optional().nullable()
     },
-    getPrismaType: () => {
+    getPrismaType: (_fieldName: string) => {
       const hasDefault = options?.defaultValue !== undefined
       let modifiers = ''
 
@@ -169,6 +360,11 @@ export function checkbox<
         modifiers = ` @default(${options.defaultValue})`
       }
 
+      // Map modifier
+      if (options?.db?.map) {
+        modifiers += ` @map("${options.db.map}")`
+      }
+
       return {
         type: 'Boolean',
         modifiers: modifiers || undefined,
@@ -195,7 +391,7 @@ export function timestamp<
     getZodSchema: () => {
       return z.union([z.date(), z.iso.datetime()]).optional().nullable()
     },
-    getPrismaType: () => {
+    getPrismaType: (_fieldName: string) => {
       let modifiers = '?'
 
       // Check for default value
@@ -208,6 +404,11 @@ export function timestamp<
         modifiers = ' @default(now())'
       }
 
+      // Map modifier
+      if (options?.db?.map) {
+        modifiers += ` @map("${options.db.map}")`
+      }
+
       return {
         type: 'DateTime',
         modifiers,
@@ -228,6 +429,131 @@ export function timestamp<
   }
 }
 
+/**
+ * Calendar Day field - date only (no time) in ISO8601 format
+ *
+ * **Features:**
+ * - Stores date values only (no time component)
+ * - PostgreSQL/MySQL: Uses native DATE type via @db.Date
+ * - SQLite: Uses String representation
+ * - Accepts ISO8601 date strings (YYYY-MM-DD format)
+ * - Optional validation for required fields
+ * - Database column mapping and nullability control
+ * - Index support (boolean or 'unique')
+ *
+ * **Usage Example:**
+ * ```typescript
+ * // In opensaas.config.ts
+ * fields: {
+ *   birthDate: calendarDay({
+ *     validation: { isRequired: true }
+ *   }),
+ *   startDate: calendarDay({
+ *     defaultValue: '2025-01-01',
+ *     db: { map: 'start_date' }
+ *   }),
+ *   endDate: calendarDay({
+ *     isIndexed: true
+ *   })
+ * }
+ *
+ * // Creating with date values
+ * const event = await context.db.event.create({
+ *   data: {
+ *     startDate: '2025-01-15',
+ *     endDate: '2025-01-20'
+ *   }
+ * })
+ * ```
+ *
+ * @param options - Field configuration options
+ * @returns Calendar Day field configuration
+ */
+export function calendarDay<
+  TTypeInfo extends import('../config/types.js').TypeInfo = import('../config/types.js').TypeInfo,
+>(options?: Omit<CalendarDayField<TTypeInfo>, 'type'>): CalendarDayField<TTypeInfo> {
+  return {
+    type: 'calendarDay',
+    ...options,
+    getZodSchema: (fieldName: string, operation: 'create' | 'update') => {
+      const validation = options?.validation
+      const isRequired = validation?.isRequired
+
+      // Accept ISO8601 date strings (YYYY-MM-DD)
+      const baseSchema = z.string({
+        message: `${formatFieldName(fieldName)} must be a valid date in ISO8601 format (YYYY-MM-DD)`,
+      })
+
+      // Validate ISO8601 date format (YYYY-MM-DD)
+      const dateSchema = baseSchema.regex(/^\d{4}-\d{2}-\d{2}$/, {
+        message: `${formatFieldName(fieldName)} must be in YYYY-MM-DD format`,
+      })
+
+      if (isRequired && operation === 'create') {
+        return dateSchema
+      } else if (isRequired && operation === 'update') {
+        // Required in update mode: can be undefined for partial updates
+        return z.union([dateSchema, z.undefined()])
+      } else {
+        return dateSchema.optional().nullable()
+      }
+    },
+    getPrismaType: (_fieldName: string, provider?: string) => {
+      const validation = options?.validation
+      const db = options?.db
+      const isRequired = validation?.isRequired
+      const isNullable = db?.isNullable ?? !isRequired
+
+      let modifiers = ''
+
+      // Optional modifier
+      if (isNullable) {
+        modifiers += '?'
+      }
+
+      // Add @db.Date attribute for date-only storage
+      // Only for PostgreSQL/MySQL - SQLite doesn't support native DATE type
+      // SQLite will use TEXT for DateTime fields
+      if (provider && provider.toLowerCase() !== 'sqlite') {
+        modifiers += ' @db.Date'
+      }
+
+      // Default value if provided
+      if (options?.defaultValue !== undefined) {
+        modifiers += ` @default("${options.defaultValue}")`
+      }
+
+      // Database mapping
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
+      }
+
+      // Unique/index modifiers
+      if (options?.isIndexed === 'unique') {
+        modifiers += ' @unique'
+      } else if (options?.isIndexed === true) {
+        modifiers += ' @index'
+      }
+
+      return {
+        type: 'DateTime',
+        modifiers: modifiers.trimStart() || undefined,
+      }
+    },
+    getTypeScriptType: () => {
+      const validation = options?.validation
+      const db = options?.db
+      const isRequired = validation?.isRequired
+      const isNullable = db?.isNullable ?? !isRequired
+
+      return {
+        type: 'Date',
+        optional: isNullable,
+      }
+    },
+  }
+}
+
 /**
  * Password field (automatically hashed using bcrypt)
  *
@@ -360,12 +686,23 @@ export function password<TTypeInfo extends import('../config/types.js').TypeInfo
           .nullable()
       }
     },
-    getPrismaType: () => {
+    getPrismaType: (_fieldName: string) => {
       const isRequired = options?.validation?.isRequired
+      let modifiers = ''
+
+      // Optional modifier
+      if (!isRequired) {
+        modifiers += '?'
+      }
+
+      // Map modifier
+      if (options?.db?.map) {
+        modifiers += ` @map("${options.db.map}")`
+      }
 
       return {
         type: 'String',
-        modifiers: isRequired ? undefined : '?',
+        modifiers: modifiers || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -404,17 +741,28 @@ export function select<
 
       return schema
     },
-    getPrismaType: () => {
-      let modifiers = '?'
+    getPrismaType: (_fieldName: string) => {
+      const isRequired = options.validation?.isRequired
+      let modifiers = ''
+
+      // Required fields don't get the ? modifier
+      if (!isRequired) {
+        modifiers = '?'
+      }
 
       // Add default value if provided
       if (options.defaultValue !== undefined) {
         modifiers = ` @default("${options.defaultValue}")`
       }
 
+      // Map modifier
+      if (options.db?.map) {
+        modifiers += ` @map("${options.db.map}")`
+      }
+
       return {
         type: 'String',
-        modifiers,
+        modifiers: modifiers || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -539,12 +887,23 @@ export function json<
         return baseSchema.optional().nullable()
       }
     },
-    getPrismaType: () => {
+    getPrismaType: (_fieldName: string) => {
       const isRequired = options?.validation?.isRequired
+      let modifiers = ''
+
+      // Optional modifier
+      if (!isRequired) {
+        modifiers += '?'
+      }
+
+      // Map modifier
+      if (options?.db?.map) {
+        modifiers += ` @map("${options.db.map}")`
+      }
 
       return {
         type: 'Json',
-        modifiers: isRequired ? undefined : '?',
+        modifiers: modifiers || undefined,
       }
     },
     getTypeScriptType: () => {

package/src/hooks/index.ts

@@ -48,13 +48,13 @@ export async function executeResolveInput<
     | {
         operation: 'create'
         resolvedData: TCreateInput
-        item?: undefined
+        item: undefined
         context: AccessContext
       }
     | {
         operation: 'update'
         resolvedData: TUpdateInput
-        item?: TOutput
+        item: TOutput
         context: AccessContext
       },
 ): Promise<TCreateInput | TUpdateInput> {
@@ -62,9 +62,7 @@ export async function executeResolveInput<
     return args.resolvedData
   }
 
-  // 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)
+  const result = await hooks.resolveInput(args)
   return result
 }
 
@@ -78,12 +76,19 @@ export async function executeValidateInput<
   TUpdateInput = Record<string, unknown>,
 >(
   hooks: Hooks<TOutput, TCreateInput, TUpdateInput> | undefined,
-  args: {
-    operation: 'create' | 'update'
-    resolvedData: TCreateInput | TUpdateInput
-    item?: TOutput
-    context: AccessContext
-  },
+  args:
+    | {
+        operation: 'create'
+        resolvedData: TCreateInput
+        item: undefined
+        context: AccessContext
+      }
+    | {
+        operation: 'update'
+        resolvedData: TUpdateInput
+        item: TOutput
+        context: AccessContext
+      },
 ): Promise<void> {
   if (!hooks?.validateInput) {
     return
@@ -109,18 +114,18 @@ export async function executeValidateInput<
  * Execute beforeOperation hook
  * Runs before database operation (cannot modify data)
  */
-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'
-    resolvedData?: TCreateInput | TUpdateInput
-    item?: TOutput
-    context: AccessContext
-  },
+export async function executeBeforeOperation<TOutput = Record<string, unknown>>(
+  hooks: Hooks<TOutput> | undefined,
+  args:
+    | {
+        operation: 'create'
+        context: AccessContext
+      }
+    | {
+        operation: 'update' | 'delete'
+        item: TOutput
+        context: AccessContext
+      },
 ): Promise<void> {
   if (!hooks?.beforeOperation) {
     return
@@ -133,18 +138,21 @@ export async function executeBeforeOperation<
  * Execute afterOperation hook
  * Runs after database operation
  */
-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'
-    resolvedData?: TCreateInput | TUpdateInput
-    item: TOutput
-    context: AccessContext
-  },
+export async function executeAfterOperation<TOutput = Record<string, unknown>>(
+  hooks: Hooks<TOutput> | undefined,
+  args:
+    | {
+        operation: 'create'
+        item: TOutput
+        originalItem: undefined
+        context: AccessContext
+      }
+    | {
+        operation: 'update' | 'delete'
+        item: TOutput
+        originalItem: TOutput
+        context: AccessContext
+      },
 ): Promise<void> {
   if (!hooks?.afterOperation) {
     return

package/tests/hooks.test.ts

@@ -252,6 +252,70 @@ describe('Hooks', () => {
         context: mockContext,
       })
     })
+
+    it('should pass originalItem to afterOperation hook for update operation', async () => {
+      const originalItem = { id: '1', name: 'John' }
+      const updatedItem = { id: '1', name: 'Jane' }
+      const hooks: Hooks = {
+        afterOperation: vi.fn(async () => {}),
+      }
+
+      await executeAfterOperation(hooks, {
+        operation: 'update',
+        item: updatedItem,
+        originalItem,
+        context: mockContext,
+      })
+
+      expect(hooks.afterOperation).toHaveBeenCalledWith({
+        operation: 'update',
+        item: updatedItem,
+        originalItem,
+        context: mockContext,
+      })
+    })
+
+    it('should pass originalItem to afterOperation hook for delete operation', async () => {
+      const item = { id: '1', name: 'John' }
+      const hooks: Hooks = {
+        afterOperation: vi.fn(async () => {}),
+      }
+
+      await executeAfterOperation(hooks, {
+        operation: 'delete',
+        item,
+        originalItem: item,
+        context: mockContext,
+      })
+
+      expect(hooks.afterOperation).toHaveBeenCalledWith({
+        operation: 'delete',
+        item,
+        originalItem: item,
+        context: mockContext,
+      })
+    })
+
+    it('should pass undefined originalItem for create operation', async () => {
+      const item = { id: '1', name: 'John' }
+      const hooks: Hooks = {
+        afterOperation: vi.fn(async () => {}),
+      }
+
+      await executeAfterOperation(hooks, {
+        operation: 'create',
+        item,
+        originalItem: undefined,
+        context: mockContext,
+      })
+
+      expect(hooks.afterOperation).toHaveBeenCalledWith({
+        operation: 'create',
+        item,
+        originalItem: undefined,
+        context: mockContext,
+      })
+    })
   })
 
   describe('validateFieldRules', () => {