@opensaas/stack-core 0.10.0 → 0.12.0

package/src/config/types.ts

@@ -43,7 +43,9 @@ export type FieldHooks<
    *
    * @example
    * ```typescript
-   * resolveInput: async ({ inputValue, operation }) => {
+   * resolveInput: async ({ inputValue, operation, item }) => {
+   *   // For create operations, item is undefined
+   *   // For update operations, item is the existing record
    *   if (typeof inputValue === 'string' && !isHashedPassword(inputValue)) {
    *     return await hashPassword(inputValue)
    *   }
@@ -51,14 +53,25 @@ export type FieldHooks<
    * }
    * ```
    */
-  resolveInput?: (args: {
-    operation: 'create' | 'update'
-    inputValue: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
-    item?: TTypeInfo['item']
-    listKey: string
-    fieldName: TFieldKey
-    context: import('../access/types.js').AccessContext
-  }) =>
+  resolveInput?: (
+    args:
+      | {
+          operation: 'create'
+          inputValue: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
+          item: undefined
+          listKey: string
+          fieldName: TFieldKey
+          context: import('../access/types.js').AccessContext
+        }
+      | {
+          operation: 'update'
+          inputValue: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
+          item: TTypeInfo['item']
+          listKey: string
+          fieldName: TFieldKey
+          context: import('../access/types.js').AccessContext
+        },
+  ) =>
     | Promise<GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined>
     | GetFieldValueType<TTypeInfo['fields'], TFieldKey>
     | undefined
@@ -71,19 +84,34 @@ export type FieldHooks<
    * @example
    * ```typescript
    * beforeOperation: async ({ resolvedValue, operation, item }) => {
-   *   console.log(`About to ${operation} field with value:`, resolvedValue)
+   *   // For create operations, item is undefined
+   *   // For update/delete operations, item is the existing record
+   *   if (operation === 'update' && item) {
+   *     console.log(`Updating field from ${item.fieldName} to ${resolvedValue}`)
+   *   }
    *   await sendAuditLog({ operation, item })
    * }
    * ```
    */
-  beforeOperation?: (args: {
-    operation: 'create' | 'update' | 'delete'
-    resolvedValue: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
-    item?: TTypeInfo['item']
-    listKey: string
-    fieldName: TFieldKey
-    context: import('../access/types.js').AccessContext
-  }) => Promise<void> | void
+  beforeOperation?: (
+    args:
+      | {
+          operation: 'create'
+          resolvedValue: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
+          item: undefined
+          listKey: string
+          fieldName: TFieldKey
+          context: import('../access/types.js').AccessContext
+        }
+      | {
+          operation: 'update' | 'delete'
+          resolvedValue: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
+          item: TTypeInfo['item']
+          listKey: string
+          fieldName: TFieldKey
+          context: import('../access/types.js').AccessContext
+        },
+  ) => Promise<void> | void
 
   /**
    * Perform side effects after database operation
@@ -92,20 +120,38 @@ export type FieldHooks<
    *
    * @example
    * ```typescript
-   * afterOperation: async ({ operation, value, item }) => {
+   * afterOperation: async ({ operation, value, item, originalItem }) => {
+   *   // For query/create operations, originalItem is undefined
+   *   // For update/delete operations, originalItem is the item before the operation
+   *   if (operation === 'update' && originalItem) {
+   *     console.log('Changed from:', originalItem[fieldName], 'to:', value)
+   *   }
    *   await invalidateCache({ listKey, itemId: item.id })
    *   await sendWebhook({ operation, item })
    * }
    * ```
    */
-  afterOperation?: (args: {
-    operation: 'create' | 'update' | 'delete' | 'query'
-    value: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
-    item: TTypeInfo['item']
-    listKey: string
-    fieldName: TFieldKey
-    context: import('../access/types.js').AccessContext
-  }) => Promise<void> | void
+  afterOperation?: (
+    args:
+      | {
+          operation: 'query' | 'create'
+          value: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
+          item: TTypeInfo['item']
+          originalItem: undefined
+          listKey: string
+          fieldName: TFieldKey
+          context: import('../access/types.js').AccessContext
+        }
+      | {
+          operation: 'update' | 'delete'
+          value: GetFieldValueType<TTypeInfo['fields'], TFieldKey> | undefined
+          item: TTypeInfo['item']
+          originalItem: TTypeInfo['item']
+          listKey: string
+          fieldName: TFieldKey
+          context: import('../access/types.js').AccessContext
+        },
+  ) => Promise<void> | void
 
   /**
    * Transform field value after database read
@@ -175,6 +221,23 @@ export type BaseFieldConfig<TTypeInfo extends TypeInfo> = {
    * Transforms field values and types in query results using Prisma's native extension system
    */
   resultExtension?: ResultExtensionConfig
+  /**
+   * Database configuration
+   */
+  db?: {
+    /**
+     * Custom database column name
+     * Adds a @map attribute in Prisma schema
+     * @example
+     * ```typescript
+     * fields: {
+     *   firstName: text({ db: { map: 'first_name' } })
+     * }
+     * // Generates: firstName String @map("first_name")
+     * ```
+     */
+    map?: string
+  }
   ui?: {
     /**
      * Custom React component to render this field
@@ -214,9 +277,13 @@ export type BaseFieldConfig<TTypeInfo extends TypeInfo> = {
   /**
    * Get Prisma type and modifiers for schema generation
    * @param fieldName - The name of the field (for generating modifiers)
+   * @param provider - Optional database provider ('sqlite', 'postgresql', 'mysql', etc.)
    * @returns Prisma type string and optional modifiers
    */
-  getPrismaType?: (fieldName: string) => {
+  getPrismaType?: (
+    fieldName: string,
+    provider?: string,
+  ) => {
     type: string
     modifiers?: string
   }
@@ -261,6 +328,37 @@ export type TextField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfig<T
     }
   }
   isIndexed?: boolean | 'unique'
+  db?: {
+    map?: string
+    /**
+     * Prisma native database type attribute
+     * Allows overriding the default String type for the database provider
+     * @example
+     * ```typescript
+     * // PostgreSQL/MySQL
+     * fields: {
+     *   description: text({ db: { nativeType: 'Text' } })
+     *   // Generates: description String @db.Text
+     * }
+     * ```
+     */
+    nativeType?: string
+    /**
+     * Controls nullability in the database schema
+     * When specified, overrides the default behavior (isRequired determines nullability)
+     * @example
+     * ```typescript
+     * fields: {
+     *   description: text({
+     *     validation: { isRequired: true },
+     *     db: { isNullable: false }
+     *   })
+     *   // Generates: description String (non-nullable)
+     * }
+     * ```
+     */
+    isNullable?: boolean
+  }
   ui?: {
     displayMode?: 'input' | 'textarea'
   }
@@ -275,6 +373,23 @@ export type IntegerField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfi
   }
 }
 
+export type DecimalField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfig<TTypeInfo> & {
+  type: 'decimal'
+  defaultValue?: string
+  precision?: number
+  scale?: number
+  db?: {
+    map?: string
+    isNullable?: boolean
+  }
+  validation?: {
+    isRequired?: boolean
+    min?: string
+    max?: string
+  }
+  isIndexed?: boolean | 'unique'
+}
+
 export type CheckboxField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfig<TTypeInfo> & {
   type: 'checkbox'
 }
@@ -284,6 +399,19 @@ export type TimestampField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldCon
   defaultValue?: { kind: 'now' } | Date
 }
 
+export type CalendarDayField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfig<TTypeInfo> & {
+  type: 'calendarDay'
+  defaultValue?: string
+  db?: {
+    map?: string
+    isNullable?: boolean
+  }
+  validation?: {
+    isRequired?: boolean
+  }
+  isIndexed?: boolean | 'unique'
+}
+
 export type PasswordField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfig<TTypeInfo> & {
   type: 'password'
   validation?: {
@@ -309,18 +437,32 @@ export type RelationshipField<TTypeInfo extends TypeInfo = TypeInfo> =
     many?: boolean
     db?: {
       /**
-       * Controls foreign key placement for bidirectional relationships
+       * Controls foreign key placement and column name for bidirectional relationships
+       * Can be a boolean or an object with a map property
        * Only valid on single (non-many) relationships
        * Cannot be true on both sides of a one-to-one relationship
        *
+       * When a boolean, defaults the foreign key column name to the field name
+       * When an object with map, uses the provided column name
+       *
        * @example
        * ```typescript
-       * // One-to-one: User has one Account
+       * // One-to-one: User has one Account (default foreign key name)
        * User: list({
        *   fields: {
        *     account: relationship({ ref: 'Account.user', db: { foreignKey: true } })
+       *     // Generates: accountId String? @unique
+       *   }
+       * })
+       *
+       * // One-to-one: User has one Account (custom foreign key name)
+       * User: list({
+       *   fields: {
+       *     account: relationship({ ref: 'Account.user', db: { foreignKey: { map: 'account_id' } } })
+       *     // Generates: accountId String? @unique @map("account_id")
        *   }
        * })
+       *
        * Account: list({
        *   fields: {
        *     user: relationship({ ref: 'User.account' }) // No foreign key on this side
@@ -328,7 +470,7 @@ export type RelationshipField<TTypeInfo extends TypeInfo = TypeInfo> =
        * })
        * ```
        */
-      foreignKey?: boolean
+      foreignKey?: boolean | { map?: string }
     }
     ui?: {
       displayMode?: 'select' | 'cards'
@@ -567,19 +709,69 @@ export type ResolveInputHookArgs<
     }
 
 /**
- * Hook arguments for other hooks (validateInput, beforeOperation, afterOperation)
- * These hooks receive the same structure regardless of operation
+ * Hook arguments for validateInput hook
+ * Uses discriminated union to provide proper types based on operation
+ * - create: resolvedData is CreateInput, item is undefined
+ * - update: resolvedData is UpdateInput, item is the existing record
  */
-export type HookArgs<
+export type ValidateInputHookArgs<
   TOutput = Record<string, unknown>,
   TCreateInput = Record<string, unknown>,
   TUpdateInput = Record<string, unknown>,
-> = {
-  operation: 'create' | 'update' | 'delete'
-  resolvedData?: TCreateInput | TUpdateInput
-  item?: TOutput
-  context: import('../access/types.js').AccessContext
-}
+> =
+  | {
+      operation: 'create'
+      resolvedData: TCreateInput
+      item: undefined
+      context: import('../access/types.js').AccessContext
+      addValidationError: (msg: string) => void
+    }
+  | {
+      operation: 'update'
+      resolvedData: TUpdateInput
+      item: TOutput
+      context: import('../access/types.js').AccessContext
+      addValidationError: (msg: string) => void
+    }
+
+/**
+ * Hook arguments for beforeOperation hook
+ * Uses discriminated union to provide proper types based on operation
+ * - create: no resolvedData, no item
+ * - update: no resolvedData, has item
+ * - delete: no resolvedData, has item
+ */
+export type BeforeOperationHookArgs<TOutput = Record<string, unknown>> =
+  | {
+      operation: 'create'
+      context: import('../access/types.js').AccessContext
+    }
+  | {
+      operation: 'update' | 'delete'
+      item: TOutput
+      context: import('../access/types.js').AccessContext
+    }
+
+/**
+ * Hook arguments for afterOperation hook
+ * Uses discriminated union to provide proper types based on operation
+ * - create: has item, no originalItem
+ * - update: has item, has originalItem
+ * - delete: has item, has originalItem
+ */
+export type AfterOperationHookArgs<TOutput = Record<string, unknown>> =
+  | {
+      operation: 'create'
+      item: TOutput
+      originalItem: undefined
+      context: import('../access/types.js').AccessContext
+    }
+  | {
+      operation: 'update' | 'delete'
+      item: TOutput
+      originalItem: TOutput
+      context: import('../access/types.js').AccessContext
+    }
 
 export type Hooks<
   TOutput = Record<string, unknown>,
@@ -590,13 +782,10 @@ export type Hooks<
     args: ResolveInputHookArgs<TOutput, TCreateInput, TUpdateInput>,
   ) => Promise<TCreateInput | TUpdateInput>
   validateInput?: (
-    args: HookArgs<TOutput, TCreateInput, TUpdateInput> & {
-      operation: 'create' | 'update'
-      addValidationError: (msg: string) => void
-    },
+    args: ValidateInputHookArgs<TOutput, TCreateInput, TUpdateInput>,
   ) => Promise<void>
-  beforeOperation?: (args: HookArgs<TOutput, TCreateInput, TUpdateInput>) => Promise<void>
-  afterOperation?: (args: HookArgs<TOutput, TCreateInput, TUpdateInput>) => Promise<void>
+  beforeOperation?: (args: BeforeOperationHookArgs<TOutput>) => Promise<void>
+  afterOperation?: (args: AfterOperationHookArgs<TOutput>) => Promise<void>
 }
 
 // Generic `any` default allows ListConfig to work with any list item type

package/src/context/index.ts

@@ -107,6 +107,8 @@ async function executeFieldAfterOperationHooks(
   operation: 'create' | 'update' | 'delete' | 'query',
   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)) {
     // Skip if no hooks defined
@@ -122,6 +124,7 @@ async function executeFieldAfterOperationHooks(
       fieldName,
       listKey,
       item,
+      originalItem,
       context,
     })
   }
@@ -483,6 +486,7 @@ function createFindUnique<TPrisma extends PrismaClientLike>(
       'query',
       context,
       listName,
+      undefined, // originalItem is undefined for query operations
     )
 
     return filtered
@@ -579,6 +583,7 @@ function createFindMany<TPrisma extends PrismaClientLike>(
           'query',
           context,
           listName,
+          undefined, // originalItem is undefined for query operations
         ),
       ),
     )
@@ -616,6 +621,7 @@ function createCreate<TPrisma extends PrismaClientLike>(
     let resolvedData = await executeResolveInput(listConfig.hooks, {
       operation: 'create',
       resolvedData: args.data,
+      item: undefined,
       context,
     })
 
@@ -632,6 +638,7 @@ function createCreate<TPrisma extends PrismaClientLike>(
     await executeValidateInput(listConfig.hooks, {
       operation: 'create',
       resolvedData,
+      item: undefined,
       context,
     })
 
@@ -677,6 +684,7 @@ function createCreate<TPrisma extends PrismaClientLike>(
     await executeAfterOperation(listConfig.hooks, {
       operation: 'create',
       item,
+      originalItem: undefined,
       context,
     })
 
@@ -688,6 +696,7 @@ function createCreate<TPrisma extends PrismaClientLike>(
       'create',
       context,
       listName,
+      undefined, // originalItem is undefined for create operations
     )
 
     // 11. Filter readable fields and apply resolveOutput hooks (including nested relationships)
@@ -832,6 +841,7 @@ function createUpdate<TPrisma extends PrismaClientLike>(
     await executeAfterOperation(listConfig.hooks, {
       operation: 'update',
       item: updated,
+      originalItem: item, // item is the original item before the update
       context,
     })
 
@@ -843,6 +853,7 @@ function createUpdate<TPrisma extends PrismaClientLike>(
       'update',
       context,
       listName,
+      item, // item is the original item before the update
     )
 
     // 12. Filter readable fields and apply resolveOutput hooks (including nested relationships)
@@ -930,6 +941,7 @@ function createDelete<TPrisma extends PrismaClientLike>(
     await executeAfterOperation(listConfig.hooks, {
       operation: 'delete',
       item: deleted,
+      originalItem: item, // item is the original item before deletion
       context,
     })
 
@@ -941,6 +953,7 @@ function createDelete<TPrisma extends PrismaClientLike>(
       'delete',
       context,
       listName,
+      item, // item is the original item before deletion
     )
 
     return deleted

package/src/context/nested-operations.ts

@@ -87,6 +87,7 @@ async function processNestedCreate(
       let resolvedData = await executeResolveInput(relatedListConfig.hooks, {
         operation: 'create',
         resolvedData: item,
+        item: undefined,
         context,
       })
 
@@ -113,6 +114,7 @@ async function processNestedCreate(
       await executeValidateInput(relatedListConfig.hooks, {
         operation: 'create',
         resolvedData,
+        item: undefined,
         context,
       })