@opensaas/stack-core 0.18.1 → 0.19.0

package/src/fields/index.ts

@@ -97,7 +97,7 @@ export function text<
 
       return {
         type: 'String',
-        modifiers: modifiers || undefined,
+        modifiers: modifiers.trimStart() || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -145,22 +145,30 @@ export function integer<
         : withMax
     },
     getPrismaType: (_fieldName: string) => {
-      const isRequired = options?.validation?.isRequired
+      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.SmallInt, @db.BigInt)
+      if (db?.nativeType) {
+        modifiers += ` @db.${db.nativeType}`
+      }
+
       // Map modifier
-      if (options?.db?.map) {
-        modifiers += ` @map("${options.db.map}")`
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
       }
 
       return {
         type: 'Int',
-        modifiers: modifiers || undefined,
+        modifiers: modifiers.trimStart() || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -353,21 +361,28 @@ export function checkbox<
       return z.boolean().optional().nullable()
     },
     getPrismaType: (_fieldName: string) => {
+      const db = options?.db
       const hasDefault = options?.defaultValue !== undefined
       let modifiers = ''
 
+      // Nullable modifier - checkbox fields are non-nullable by default (must be true or false)
+      // Use db.isNullable: true to allow NULL values in the database
+      if (db?.isNullable === true) {
+        modifiers += '?'
+      }
+
       if (hasDefault) {
-        modifiers = ` @default(${options.defaultValue})`
+        modifiers += ` @default(${options.defaultValue})`
       }
 
       // Map modifier
-      if (options?.db?.map) {
-        modifiers += ` @map("${options.db.map}")`
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
       }
 
       return {
         type: 'Boolean',
-        modifiers: modifiers || undefined,
+        modifiers: modifiers.trimStart() || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -392,26 +407,41 @@ export function timestamp<
       return z.union([z.date(), z.iso.datetime()]).optional().nullable()
     },
     getPrismaType: (_fieldName: string) => {
-      let modifiers = '?'
-
-      // Check for default value
-      if (
+      const db = options?.db
+      const hasDefaultNow =
         options?.defaultValue &&
         typeof options.defaultValue === 'object' &&
         'kind' in options.defaultValue &&
         options.defaultValue.kind === 'now'
-      ) {
-        modifiers = ' @default(now())'
+
+      // Nullability: explicit db.isNullable overrides the default (nullable unless @default(now()))
+      const isNullable = db?.isNullable ?? !hasDefaultNow
+
+      let modifiers = ''
+
+      // Optional modifier
+      if (isNullable) {
+        modifiers += '?'
+      }
+
+      // Default value
+      if (hasDefaultNow) {
+        modifiers += ' @default(now())'
+      }
+
+      // Native type modifier (e.g., @db.Timestamptz for PostgreSQL)
+      if (db?.nativeType) {
+        modifiers += ` @db.${db.nativeType}`
       }
 
       // Map modifier
-      if (options?.db?.map) {
-        modifiers += ` @map("${options.db.map}")`
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
       }
 
       return {
         type: 'DateTime',
-        modifiers,
+        modifiers: modifiers.trimStart() || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -623,8 +653,10 @@ export function password<TTypeInfo extends import('../config/types.js').TypeInfo
     hooks: {
       // Hash password before writing to database
       // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Field builder hooks must be generic
-      resolveInput: async ({ inputValue }: { inputValue: any }) => {
+      resolveInput: async ({ inputData, fieldKey }: { inputData: any; fieldKey: string }) => {
         // Skip if undefined or null (allows partial updates)
+        const inputValue = inputData[fieldKey]
+        console.log('Password resolveInput called with value:', inputValue)
         if (inputValue === undefined || inputValue === null) {
           return inputValue
         }
@@ -640,7 +672,7 @@ export function password<TTypeInfo extends import('../config/types.js').TypeInfo
         }
 
         // Hash the password
-        return await hashPassword(inputValue)
+        return (await hashPassword(inputValue)).toString()
       },
       // Wrap password with HashedPassword class after reading from database
       // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Field builder hooks must be generic
@@ -687,22 +719,30 @@ export function password<TTypeInfo extends import('../config/types.js').TypeInfo
       }
     },
     getPrismaType: (_fieldName: string) => {
-      const isRequired = options?.validation?.isRequired
+      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}`
+      }
+
       // Map modifier
-      if (options?.db?.map) {
-        modifiers += ` @map("${options.db.map}")`
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
       }
 
       return {
         type: 'String',
-        modifiers: modifiers || undefined,
+        modifiers: modifiers.trimStart() || undefined,
       }
     },
     getTypeScriptType: () => {
@@ -716,6 +756,11 @@ export function password<TTypeInfo extends import('../config/types.js').TypeInfo
   }
 }
 
+/**
+ * Valid Prisma enum value pattern: starts with a letter, followed by letters, digits, or underscores
+ */
+const PRISMA_ENUM_VALUE_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/
+
 /**
  * Select field (enum-like)
  */
@@ -726,6 +771,20 @@ export function select<
     throw new Error('Select field must have at least one option')
   }
 
+  const isNativeEnum = options.db?.type === 'enum'
+
+  if (isNativeEnum) {
+    const invalidValues = options.options
+      .map((opt) => opt.value)
+      .filter((value) => !PRISMA_ENUM_VALUE_PATTERN.test(value))
+
+    if (invalidValues.length > 0) {
+      throw new Error(
+        `Enum select field values must be valid Prisma identifiers (letters, numbers, and underscores, starting with a letter). Invalid values: ${invalidValues.join(', ')}`,
+      )
+    }
+  }
+
   return {
     type: 'select',
     ...options,
@@ -741,10 +800,39 @@ export function select<
 
       return schema
     },
-    getPrismaType: (_fieldName: string) => {
+    getPrismaType: (fieldName: string, _provider?: string, listName?: string) => {
       const isRequired = options.validation?.isRequired
       let modifiers = ''
 
+      if (isNativeEnum) {
+        // Derive enum name from list name + field name in PascalCase
+        const capitalizedField = fieldName.charAt(0).toUpperCase() + fieldName.slice(1)
+        const enumName = listName ? `${listName}${capitalizedField}` : capitalizedField
+
+        // Required fields don't get the ? modifier
+        if (!isRequired) {
+          modifiers = '?'
+        }
+
+        // Add default value if provided (no quotes for enum values)
+        if (options.defaultValue !== undefined) {
+          modifiers = ` @default(${options.defaultValue})`
+        }
+
+        // Map modifier
+        if (options.db?.map) {
+          modifiers += ` @map("${options.db.map}")`
+        }
+
+        return {
+          type: enumName,
+          modifiers: modifiers || undefined,
+          enumValues: options.options.map((opt) => opt.value),
+        }
+      }
+
+      // String type (default)
+
       // Required fields don't get the ? modifier
       if (!isRequired) {
         modifiers = '?'
@@ -766,7 +854,7 @@ export function select<
       }
     },
     getTypeScriptType: () => {
-      // Generate union type from options
+      // Generate union type from options (same for both string and enum db types)
       const unionType = options.options.map((opt) => `'${opt.value}'`).join(' | ')
 
       return {
@@ -888,22 +976,30 @@ export function json<
       }
     },
     getPrismaType: (_fieldName: string) => {
-      const isRequired = options?.validation?.isRequired
+      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
+      if (db?.nativeType) {
+        modifiers += ` @db.${db.nativeType}`
+      }
+
       // Map modifier
-      if (options?.db?.map) {
-        modifiers += ` @map("${options.db.map}")`
+      if (db?.map) {
+        modifiers += ` @map("${db.map}")`
       }
 
       return {
         type: 'Json',
-        modifiers: modifiers || undefined,
+        modifiers: modifiers.trimStart() || undefined,
       }
     },
     getTypeScriptType: () => {

package/src/fields/select.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect } from 'vitest'
+import { select } from './index.js'
+
+describe('select field builder', () => {
+  describe('string type (default)', () => {
+    it('should throw when no options are provided', () => {
+      expect(() => select({ options: [] })).toThrow('Select field must have at least one option')
+    })
+
+    it('should return String prisma type for default select field', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.type).toBe('String')
+      expect(result.enumValues).toBeUndefined()
+    })
+
+    it('should add ? modifier for optional string select', () => {
+      const field = select({
+        options: [{ label: 'Draft', value: 'draft' }],
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBe('?')
+    })
+
+    it('should not add ? modifier for required string select', () => {
+      const field = select({
+        options: [{ label: 'Draft', value: 'draft' }],
+        validation: { isRequired: true },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBeUndefined()
+    })
+
+    it('should generate quoted default value for string select', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        defaultValue: 'draft',
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBe(' @default("draft")')
+    })
+
+    it('should generate union TypeScript type from options', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+      })
+
+      const result = field.getTypeScriptType!()
+      expect(result.type).toBe("'draft' | 'published'")
+      expect(result.optional).toBe(true)
+    })
+
+    it('should mark TypeScript type as non-optional when required', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        validation: { isRequired: true },
+      })
+
+      const result = field.getTypeScriptType!()
+      expect(result.optional).toBe(false)
+    })
+  })
+
+  describe('enum type (db.type: enum)', () => {
+    it('should throw for values that are not valid Prisma identifiers (hyphens)', () => {
+      expect(() =>
+        select({
+          options: [{ label: 'In Progress', value: 'in-progress' }],
+          db: { type: 'enum' },
+        }),
+      ).toThrow(/valid Prisma identifiers/)
+    })
+
+    it('should throw for values starting with a digit', () => {
+      expect(() =>
+        select({
+          options: [{ label: 'First', value: '1st' }],
+          db: { type: 'enum' },
+        }),
+      ).toThrow(/valid Prisma identifiers/)
+    })
+
+    it('should throw for values with spaces', () => {
+      expect(() =>
+        select({
+          options: [{ label: 'In Progress', value: 'in progress' }],
+          db: { type: 'enum' },
+        }),
+      ).toThrow(/valid Prisma identifiers/)
+    })
+
+    it('should accept values with underscores', () => {
+      expect(() =>
+        select({
+          options: [
+            { label: 'In Progress', value: 'in_progress' },
+            { label: 'Done', value: 'done' },
+          ],
+          db: { type: 'enum' },
+        }),
+      ).not.toThrow()
+    })
+
+    it('should return derived enum name from listName + fieldName', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        db: { type: 'enum' },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.type).toBe('PostStatus')
+    })
+
+    it('should capitalize fieldName when deriving enum name', () => {
+      const field = select({
+        options: [
+          { label: 'Article', value: 'article' },
+          { label: 'Video', value: 'video' },
+        ],
+        db: { type: 'enum' },
+      })
+
+      const result = field.getPrismaType!('contentType', 'sqlite', 'Post')
+      expect(result.type).toBe('PostContentType')
+    })
+
+    it('should fall back to capitalized fieldName when listName is not provided', () => {
+      const field = select({
+        options: [{ label: 'Draft', value: 'draft' }],
+        db: { type: 'enum' },
+      })
+
+      const result = field.getPrismaType!('status')
+      expect(result.type).toBe('Status')
+    })
+
+    it('should return enumValues in getPrismaType result', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        db: { type: 'enum' },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.enumValues).toEqual(['draft', 'published'])
+    })
+
+    it('should add ? modifier for optional enum field', () => {
+      const field = select({
+        options: [{ label: 'Draft', value: 'draft' }],
+        db: { type: 'enum' },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBe('?')
+    })
+
+    it('should not add ? modifier for required enum field', () => {
+      const field = select({
+        options: [{ label: 'Draft', value: 'draft' }],
+        db: { type: 'enum' },
+        validation: { isRequired: true },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBeUndefined()
+    })
+
+    it('should generate unquoted default value for enum field', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        db: { type: 'enum' },
+        defaultValue: 'draft',
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBe(' @default(draft)')
+      // Explicitly check there are no quotes
+      expect(result.modifiers).not.toContain('"')
+    })
+
+    it('should include @map modifier for enum field with map option', () => {
+      const field = select({
+        options: [{ label: 'Draft', value: 'draft' }],
+        db: { type: 'enum', map: 'post_status' },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toContain('@map("post_status")')
+    })
+
+    it('should generate same union TypeScript type as string select', () => {
+      const enumField = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        db: { type: 'enum' },
+      })
+
+      const stringField = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+      })
+
+      expect(enumField.getTypeScriptType!()).toEqual(stringField.getTypeScriptType!())
+    })
+  })
+})

package/src/validation/schema.test.ts

@@ -49,6 +49,22 @@ describe('Zod Schema Generation', () => {
       expect(schema).toBeDefined()
     })
 
+    it('should generate schema for enum select field', () => {
+      const fields: Record<string, FieldConfig> = {
+        status: select({
+          options: [
+            { label: 'Draft', value: 'draft' },
+            { label: 'Published', value: 'published' },
+          ],
+          db: { type: 'enum' },
+          validation: { isRequired: true },
+        }),
+      }
+
+      const schema = generateZodSchema(fields, 'create')
+      expect(schema).toBeDefined()
+    })
+
     it('should make fields optional in update mode', () => {
       const fields: Record<string, FieldConfig> = {
         name: text({ validation: { isRequired: true } }),
@@ -149,6 +165,41 @@ describe('Zod Schema Generation', () => {
       }
     })
 
+    it('should pass validation for valid enum select value', () => {
+      const fields: Record<string, FieldConfig> = {
+        status: select({
+          options: [
+            { label: 'Draft', value: 'draft' },
+            { label: 'Published', value: 'published' },
+          ],
+          db: { type: 'enum' },
+          validation: { isRequired: true },
+        }),
+      }
+
+      const result = validateWithZod({ status: 'draft' }, fields, 'create')
+      expect(result.success).toBe(true)
+    })
+
+    it('should fail validation for invalid enum select value', () => {
+      const fields: Record<string, FieldConfig> = {
+        status: select({
+          options: [
+            { label: 'Draft', value: 'draft' },
+            { label: 'Published', value: 'published' },
+          ],
+          db: { type: 'enum' },
+          validation: { isRequired: true },
+        }),
+      }
+
+      const result = validateWithZod({ status: 'archived' }, fields, 'create')
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.errors.status).toBeDefined()
+      }
+    })
+
     it('should skip system fields in validation', () => {
       const fields: Record<string, FieldConfig> = {
         id: text(),

package/tests/access-relationships.test.ts

@@ -7,6 +7,23 @@ describe('Relationship Access Control', () => {
     session: null,
     prisma: {},
     db: {},
+    storage: {
+      uploadFile: async () => {
+        throw new Error('Not implemented')
+      },
+      uploadImage: async () => {
+        throw new Error('Not implemented')
+      },
+      deleteFile: async () => {
+        throw new Error('Not implemented')
+      },
+      deleteImage: async () => {
+        throw new Error('Not implemented')
+      },
+    },
+    plugins: {},
+    _isSudo: false,
+    _resolveOutputCounter: { depth: 0 },
   }
 
   describe('getRelatedListConfig', () => {