pipework 0.252.0 → 0.252.1

package/src/data/domain/build-factory.ts

@@ -0,0 +1,193 @@
+import { randomUUID } from 'node:crypto'
+import type { DB } from '../db/types.js'
+import type { DefinedTable, FactoryBuilder, FactoryOptions, FieldMeta } from './types.js'
+import { resolveDefinitionRef } from './types.js'
+import { getContext } from '../../request/context/store.js'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any DefinedTable regardless of field generics
+export function projectFactory(definition: DefinedTable<any>): FactoryBuilder {
+  return {
+    async create(overrides, options) {
+      const values = await buildValues(definition, overrides ?? {}, options)
+
+      if (definition.$options.virtual === true) {
+        return values
+      }
+
+      const db = resolveDb(definition, options)
+      const table = definition.table()
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Drizzle insert requires runtime table type
+      const [row] = await (db as any).insert(table).values(values).returning()
+      return row as Record<string, unknown>
+    },
+
+    async createMany(count, overrides, options) {
+      const rows: Record<string, unknown>[] = []
+      for (let i = 0; i < count; i++) {
+        const ov = typeof overrides === 'function' ? overrides(i) : (overrides ?? {})
+        rows.push(await this.create(ov, options))
+      }
+      return rows
+    },
+  }
+}
+
+function resolveDb(definition: DefinedTable, options?: FactoryOptions): DB {
+  if (options?.db !== undefined) {
+    return options.db as DB
+  }
+
+  const ctx = getContext()
+  if (ctx === undefined) {
+    throw new Error(
+      `[pipework] .factory().create() requires an active context or explicit { db } option.\n\n` +
+      '  In a test body: ensure you have test isolation set up (pipework wraps each test in a flow context).\n' +
+      '  In beforeAll: pass { db: useSetupDb() } as the options argument.\n',
+    )
+  }
+
+  const dbName = definition.$options.database ?? ctx.instance.config.defaultDatabaseName()
+  const dbConfig = ctx.instance.config.database(dbName)
+
+  const bound = ctx.transactions.get(dbName)
+  if (bound !== undefined) {
+    return bound.drizzle
+  }
+
+  return ctx.instance.pool.getOrCreate(dbConfig).drizzle
+}
+
+async function buildValues(
+  definition: DefinedTable,
+  overrides: Partial<Record<string, unknown>>,
+  options?: FactoryOptions,
+): Promise<Record<string, unknown>> {
+  const values: Record<string, unknown> = {}
+
+  for (const [key, descriptor] of Object.entries(definition.$fields)) {
+    const meta = descriptor._meta
+
+    if (meta.generated !== undefined) {
+      if (key in overrides) {
+        throw new Error(
+          `[pipework] factory override for "${key}" on "${definition.$name}": the field is a generated column, which Postgres computes.\n\n` +
+          `  Fix: drop "${key}" from the overrides and set the fields its expression reads.\n`,
+        )
+      }
+      continue
+    }
+
+    if (key in overrides) {
+      values[key] = overrides[key]
+      continue
+    }
+
+    if (meta.primaryKey && meta.defaultRandom) continue
+    if (meta.hasDefault) continue
+    if (meta.nullable) continue
+
+    if (meta.tenant) {
+      values[key] = resolveTenantId(options)
+      continue
+    }
+
+    if (meta.reference !== undefined) {
+      const parentDef = resolveDefinitionRef(meta.reference.definition)
+      const parent = await parentDef.factory().create(undefined, options)
+      values[key] = parent[meta.reference.field]
+      continue
+    }
+
+    values[key] = generateDefault(key, meta)
+  }
+
+  return values
+}
+
+function resolveTenantId(options?: FactoryOptions): string {
+  if (options?.tenantId !== undefined) return options.tenantId
+
+  const ctx = getContext()
+  if (ctx?.tenant !== undefined && ctx.tenant !== null) return ctx.tenant
+
+  return randomUUID()
+}
+
+let _counter = 0
+
+export function resetFactoryCounter(): void {
+  _counter = 0
+}
+
+function generateDefault(key: string, meta: FieldMeta): unknown {
+  if (meta.array) return [generateElement(key, meta)]
+  return generateElement(key, meta)
+}
+
+function generateElement(key: string, meta: FieldMeta): unknown {
+  switch (meta.kind) {
+    case 'uuid':
+      return randomUUID()
+
+    case 'text': {
+      const suffix = String(++_counter)
+      if (meta.email) return `${key}_${suffix}@test.example`
+      if (meta.url) return `https://test.example/${key}/${suffix}`
+      let text = `${key}_${suffix}`
+      if (meta.min !== undefined && text.length < meta.min) {
+        text = text.padEnd(meta.min, 'x')
+      }
+      if (meta.max !== undefined && text.length > meta.max) {
+        text = text.substring(0, meta.max)
+      }
+      return text
+    }
+
+    case 'integer':
+    case 'serial': {
+      if (meta.min !== undefined) return meta.min
+      if (meta.max !== undefined) return Math.min(0, meta.max)
+      return 0
+    }
+
+    case 'bigint': {
+      if (meta.serializedAs === 'string') return String(meta.min ?? 0)
+      return BigInt(meta.min ?? 0)
+    }
+
+    case 'boolean':
+      return false
+
+    case 'timestamp':
+      return new Date().toISOString()
+
+    case 'date':
+      return new Date().toISOString().slice(0, 10)
+
+    case 'enum': {
+      if (meta.enumValues === undefined || meta.enumValues.length === 0) {
+        throw new Error(`[pipework] Cannot generate default for enum field "${key}" — no values defined`)
+      }
+      return meta.enumValues[0]
+    }
+
+    case 'jsonb':
+      return {}
+
+    case 'decimal':
+      return '0'
+
+    case 'pgLsn':
+      return `0/${(++_counter).toString(16).toUpperCase()}`
+
+    case 'custom':
+      throw new Error(
+        `[pipework] Cannot generate default for custom field "${key}".\n\n` +
+        '  Custom fields require an explicit override or .default() value.\n' +
+        `  Pass { ${key}: <value> } to .factory().create().\n`,
+      )
+
+    default:
+      throw new Error(`[pipework] Unknown field kind: ${meta.kind as string}`)
+  }
+}

package/src/data/domain/build-schema.ts

@@ -0,0 +1,161 @@
+import { z } from 'zod/v4'
+import type { FieldDescriptor, FieldMeta, FieldRecord } from './types.js'
+import type { InsertProjection, SelectProjection, UpdateProjection } from './projections.js'
+
+export function projectInsertShape<TFields extends FieldRecord>(fields: TFields): z.ZodType<InsertProjection<TFields>>
+export function projectInsertShape(fields: Record<string, FieldDescriptor>): z.ZodType
+export function projectInsertShape(fields: Record<string, FieldDescriptor>): z.ZodType {
+  const shape: Record<string, z.ZodType> = {}
+
+  for (const [key, descriptor] of Object.entries(fields)) {
+    const meta = descriptor._meta
+
+    if (meta.primaryKey && (meta.defaultRandom || meta.kind === 'serial')) continue
+    if (meta.autoManaged) continue
+    if (meta.generated !== undefined) continue
+
+    let validator = buildValidator(meta)
+
+    if (meta.nullable) {
+      validator = validator.nullable()
+    }
+    if (meta.nullable || meta.hasDefault) {
+      validator = validator.optional()
+    }
+
+    shape[key] = validator
+  }
+
+  return z.object(shape)
+}
+
+export function projectSelectShape<TFields extends FieldRecord>(fields: TFields): z.ZodType<SelectProjection<TFields>>
+export function projectSelectShape(fields: Record<string, FieldDescriptor>): z.ZodType
+export function projectSelectShape(fields: Record<string, FieldDescriptor>): z.ZodType {
+  const shape: Record<string, z.ZodType> = {}
+
+  for (const [key, descriptor] of Object.entries(fields)) {
+    const meta = descriptor._meta
+    let validator = buildValidator(meta)
+
+    if (meta.nullable) {
+      validator = validator.nullable()
+    }
+
+    shape[key] = validator
+  }
+
+  return z.object(shape)
+}
+
+export function projectUpdateShape<TFields extends FieldRecord>(fields: TFields): z.ZodType<UpdateProjection<TFields>>
+export function projectUpdateShape(fields: Record<string, FieldDescriptor>): z.ZodType
+export function projectUpdateShape(fields: Record<string, FieldDescriptor>): z.ZodType {
+  const shape: Record<string, z.ZodType> = {}
+
+  for (const [key, descriptor] of Object.entries(fields)) {
+    const meta = descriptor._meta
+
+    if (meta.primaryKey) continue
+    if (meta.readOnly) continue
+    if (meta.autoManaged) continue
+    if (meta.generated !== undefined) continue
+
+    let validator = buildValidator(meta)
+
+    if (meta.nullable) {
+      validator = validator.nullable()
+    }
+
+    shape[key] = validator.optional()
+  }
+
+  return z.object(shape)
+}
+
+function buildValidator(meta: FieldMeta): z.ZodType {
+  const element = buildElementValidator(meta)
+  return meta.array ? z.array(element) : element
+}
+
+function buildElementValidator(meta: FieldMeta): z.ZodType {
+  switch (meta.kind) {
+    case 'uuid': {
+      let v: z.ZodType = z.string().uuid()
+      if (meta.brand !== undefined) {
+        v = v.brand(meta.brand)
+      }
+      return v
+    }
+
+    case 'text': {
+      let v: z.ZodType = z.string()
+      if (meta.min !== undefined) v = (v as z.ZodString).min(meta.min)
+      if (meta.max !== undefined) v = (v as z.ZodString).max(meta.max)
+      if (meta.email) v = (v as z.ZodString).email()
+      if (meta.url) v = (v as z.ZodString).url()
+      if (meta.regex !== undefined) v = (v as z.ZodString).regex(meta.regex)
+      if (meta.brand !== undefined) v = v.brand(meta.brand)
+      return v
+    }
+
+    case 'integer':
+    case 'serial': {
+      let v: z.ZodType = z.number().int()
+      if (meta.min !== undefined) v = (v as z.ZodNumber).min(meta.min)
+      if (meta.max !== undefined) v = (v as z.ZodNumber).max(meta.max)
+      if (meta.brand !== undefined) v = v.brand(meta.brand)
+      return v
+    }
+
+    case 'bigint': {
+      if (meta.serializedAs === 'string') {
+        let v: z.ZodType = z.string()
+        if (meta.brand !== undefined) v = v.brand(meta.brand)
+        return v
+      }
+      let v: z.ZodType = z.bigint()
+      if (meta.min !== undefined) v = (v as z.ZodBigInt).min(BigInt(meta.min))
+      if (meta.max !== undefined) v = (v as z.ZodBigInt).max(BigInt(meta.max))
+      if (meta.brand !== undefined) v = v.brand(meta.brand)
+      return v
+    }
+
+    case 'boolean':
+      return z.boolean()
+
+    case 'timestamp':
+      return z.union([z.string().datetime(), z.date()])
+
+    case 'date':
+      return z.union([z.string(), z.date()])
+
+    case 'enum':
+      if (!meta.enumValues || meta.enumValues.length === 0) {
+        throw new Error('[pipework] enum field requires at least one value')
+      }
+      return z.enum(meta.enumValues as unknown as [string, ...string[]])
+
+    case 'jsonb':
+      return meta.jsonbShape ?? z.unknown()
+
+    case 'decimal': {
+      let v: z.ZodType = z.string()
+      if (meta.brand !== undefined) v = v.brand(meta.brand)
+      return v
+    }
+
+    case 'pgLsn': {
+      // pg_lsn text form: two hex numbers separated by a slash, e.g. '0/16B3748'.
+      let v: z.ZodType = z.string().regex(/^[0-9A-Fa-f]+\/[0-9A-Fa-f]+$/)
+      if (meta.brand !== undefined) v = v.brand(meta.brand)
+      return v
+    }
+
+    case 'custom':
+      return meta.customValidator ?? z.unknown()
+
+    default:
+      throw new Error(`[pipework] Unknown field kind: ${meta.kind as string}`)
+  }
+}

package/src/data/domain/build-table.ts

@@ -0,0 +1,355 @@
+import {
+  pgTable,
+  text, uuid, integer, serial, bigint as pgBigint, boolean,
+  timestamp, date, jsonb, numeric, customType,
+  check, primaryKey, foreignKey,
+} from '../query/pg-core/index.js'
+import { sql } from '../query/index.js'
+import type { FieldDescriptor, FieldMeta, DefineOptions, CompositeForeignKey } from './types.js'
+import { resolveDefinitionRef } from './types.js'
+import { camelToSnake } from './naming.js'
+
+export function projectTable(
+  tableName: string,
+  fields: Record<string, FieldDescriptor>,
+  options: DefineOptions,
+) {
+  if (options.virtual === true) {
+    throw new Error(
+      `[pipework] "${tableName}" is a virtual definition — no database table.\n\n` +
+      '  Virtual definitions have no .table() projection.\n' +
+      '  Remove { virtual: true } if this definition needs a database table.\n',
+    )
+  }
+
+  /* eslint-disable @typescript-eslint/no-explicit-any -- Drizzle pgTable callback requires untyped column builders */
+  const { columns, extraConfig } = buildColumns(fields, false, tableName)
+
+  validateKeyOptions(tableName, fields, options)
+
+  const needsCallback =
+    options.indexes !== undefined ||
+    options.primaryKey !== undefined ||
+    options.foreignKeys !== undefined ||
+    extraConfig.length > 0
+
+  if (!needsCallback) {
+    return pgTable(tableName, columns)
+  }
+
+  return pgTable(tableName, columns, (table) => {
+    const all: any[] = [...extraConfig]
+
+    if (options.primaryKey !== undefined) {
+      all.push(primaryKey({ columns: options.primaryKey.map(k => table[k]) as [any, ...any[]] }))
+    }
+
+    if (options.foreignKeys !== undefined) {
+      for (const cfk of options.foreignKeys) {
+        all.push(buildForeignKey(cfk, table))
+      }
+    }
+
+    if (options.indexes !== undefined) {
+      const indexes = options.indexes(table)
+      for (const [, idx] of Object.entries(indexes)) {
+        all.push(idx)
+      }
+    }
+
+    return all
+  })
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+}
+
+/**
+ * Builds the column builders for a field record. With `readOnly`, only name, type
+ * and nullability are kept: keys, defaults, uniqueness, references and checks
+ * describe a table pipework owns, and a relation read from elsewhere emits none.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any -- Drizzle column builders are deeply generic */
+export function buildColumns(
+  fields: Record<string, FieldDescriptor>,
+  readOnly: boolean,
+  tableName = '',
+): { columns: Record<string, any>; extraConfig: any[] } {
+  const columns: Record<string, any> = {}
+  const extraConfig: any[] = []
+
+  for (const [key, descriptor] of Object.entries(fields)) {
+    const meta = descriptor._meta
+    const colName = camelToSnake(key)
+
+    let col = buildColumn(colName, meta)
+    if (meta.array) col = col.array()
+
+    if (!meta.nullable) {
+      col = col.notNull()
+    }
+
+    if (readOnly) {
+      columns[key] = col
+      continue
+    }
+
+    if (meta.collation !== undefined) {
+      col = col.collate(meta.collation)
+    }
+
+    if (meta.generated !== undefined) {
+      col = col.generatedAlwaysAs(meta.generated.as)
+    }
+
+    if (meta.primaryKey) {
+      col = col.primaryKey()
+    }
+
+    if (meta.unique) {
+      col = col.unique()
+    }
+
+    if (meta.defaultRandom && meta.kind === 'uuid') {
+      col = col.defaultRandom()
+    } else if (meta.hasDefault && meta.defaultValue === 'now' && meta.kind === 'timestamp') {
+      col = col.defaultNow()
+    } else if (meta.hasDefault && meta.defaultValue === 'currentWal' && meta.kind === 'pgLsn') {
+      col = col.default(sql`pg_current_wal_lsn()`)
+    } else if (meta.hasDefault && meta.defaultValue !== undefined) {
+      col = col.default(meta.defaultValue)
+    }
+
+    if (meta.reference !== undefined && meta.reference.enforced !== false) {
+      const refDef = resolveDefinitionRef(meta.reference.definition)
+      const refTable = refDef.table()
+      const refField = meta.reference.field
+      col = col.references(() => {
+        const refCol = (refTable as any)[refField]
+        if (refCol === undefined) {
+          throw new Error(
+            `[pipework] "${tableName}.${key}" references "${refDef.$name}.${refField}", which has no such field. ` +
+            `Fix: name a field key of "${refDef.$name}" (camelCase, as declared).`,
+          )
+        }
+        return refCol
+      })
+    }
+
+    columns[key] = col
+
+    buildChecks(colName, meta, extraConfig)
+  }
+
+  return { columns, extraConfig }
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+/* eslint-disable @typescript-eslint/no-explicit-any -- Drizzle column/builder types are deeply generic */
+function buildForeignKey(cfk: CompositeForeignKey, table: Record<string, any>): any {
+  const refDef = resolveDefinitionRef(cfk.references.definition)
+  const refTable = refDef.table() as Record<string, any>
+  let builder = foreignKey({
+    columns: cfk.columns.map(k => table[k]) as [any, ...any[]],
+    foreignColumns: cfk.references.columns.map(k => refTable[k]) as [any, ...any[]],
+  })
+  if (typeof cfk.onDelete === 'object') {
+    const setNull = 'setNull' in cfk.onDelete
+    const list = 'setNull' in cfk.onDelete ? cfk.onDelete.setNull : cfk.onDelete.setDefault
+    builder = builder
+      .onDelete(setNull ? 'set null' : 'set default')
+      .onDeleteColumns(list.map(k => (table[k] as { name: string }).name))
+  } else if (cfk.onDelete !== undefined) {
+    builder = builder.onDelete(cfk.onDelete)
+  }
+  if (cfk.onUpdate !== undefined) builder = builder.onUpdate(cfk.onUpdate)
+  return builder
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+function validateKeyOptions(
+  tableName: string,
+  fields: Record<string, FieldDescriptor>,
+  options: DefineOptions,
+): void {
+  const has = (key: string): boolean => Object.prototype.hasOwnProperty.call(fields, key)
+
+  if (options.primaryKey !== undefined) {
+    const fieldPk = Object.keys(fields).find(k => fields[k]!._meta.primaryKey)
+    if (fieldPk !== undefined) {
+      throw new Error(
+        `[pipework] "${tableName}" declares both a composite primaryKey option and a field-level .primaryKey() on "${fieldPk}".\n\n` +
+        '  A table has exactly one primary key.\n' +
+        `  Use the composite primaryKey option, or drop .primaryKey() from "${fieldPk}".\n`,
+      )
+    }
+    for (const key of options.primaryKey) {
+      if (!has(key)) {
+        throw new Error(
+          `[pipework] "${tableName}" primaryKey references unknown field "${key}".\n\n` +
+          `  Known fields: ${Object.keys(fields).join(', ')}\n` +
+          `  Fix the field name in the primaryKey option.\n`,
+        )
+      }
+    }
+  }
+
+  if (options.partitionBy !== undefined) {
+    const col = options.partitionBy.column
+    if (!has(col)) {
+      throw new Error(
+        `[pipework] "${tableName}" partitionBy references unknown field "${col}".\n\n` +
+        `  Known fields: ${Object.keys(fields).join(', ')}\n` +
+        `  Fix the column name in the partitionBy option.\n`,
+      )
+    }
+    if (options.primaryKey === undefined || !options.primaryKey.includes(col)) {
+      throw new Error(
+        `[pipework] "${tableName}" is partitioned by "${col}", but "${col}" is not in the primary key.\n\n` +
+        '  Postgres requires the partition column to be part of every unique constraint, including the primary key.\n' +
+        `  Add "${col}" to the primaryKey option: primaryKey: [..., '${col}'].\n`,
+      )
+    }
+  }
+
+  if (options.foreignKeys !== undefined) {
+    for (const cfk of options.foreignKeys) {
+      for (const key of cfk.columns) {
+        if (!has(key)) {
+          throw new Error(
+            `[pipework] "${tableName}" foreignKey references unknown local field "${key}".\n\n` +
+            `  Known fields: ${Object.keys(fields).join(', ')}\n` +
+            `  Fix the field name in the foreignKeys option.\n`,
+          )
+        }
+      }
+      if (cfk.columns.length !== cfk.references.columns.length) {
+        throw new Error(
+          `[pipework] "${tableName}" foreignKey column count mismatch: ${String(cfk.columns.length)} local vs ${String(cfk.references.columns.length)} foreign.\n\n` +
+          '  A composite foreign key maps local columns positionally to foreign columns.\n' +
+          '  Give the same number of columns on both sides.\n',
+        )
+      }
+      if (typeof cfk.onDelete === 'object') {
+        const action = 'setNull' in cfk.onDelete ? 'setNull' : 'setDefault'
+        const list = 'setNull' in cfk.onDelete ? cfk.onDelete.setNull : cfk.onDelete.setDefault
+        const fkName = `(${cfk.columns.join(', ')})`
+        if (list.length === 0) {
+          throw new Error(
+            `[pipework] "${tableName}" foreignKey ${fkName} onDelete { ${action} } has an empty column list.\n\n` +
+            `  Name the fields to clear, from: ${cfk.columns.join(', ')}.\n` +
+            `  To clear every column of the key, use onDelete: '${action === 'setNull' ? 'set null' : 'set default'}'.\n`,
+          )
+        }
+        const seen = new Set<string>()
+        for (const k of list) {
+          if (seen.has(k)) {
+            throw new Error(
+              `[pipework] "${tableName}" foreignKey ${fkName} onDelete { ${action} } lists "${k}" twice.\n\n` +
+              '  Remove the duplicate from the column list.\n',
+            )
+          }
+          seen.add(k)
+          if (!cfk.columns.includes(k)) {
+            throw new Error(
+              `[pipework] "${tableName}" foreignKey ${fkName} onDelete { ${action} } lists "${k}", which is not a column of the key.\n\n` +
+              `  The list must be a subset of the key's columns: ${cfk.columns.join(', ')}.\n` +
+              '  Fix the field name in the column list.\n',
+            )
+          }
+        }
+      }
+    }
+  }
+}
+
+const pgLsnColumn = customType<{ data: string }>({
+  dataType() { return 'pg_lsn' },
+})
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Drizzle column builders have deeply generic types
+function buildColumn(colName: string, meta: FieldMeta): any {
+  switch (meta.kind) {
+    case 'uuid':
+      return uuid(colName)
+    case 'text':
+      return text(colName)
+    case 'integer':
+      return integer(colName)
+    case 'serial':
+      return serial(colName)
+    case 'bigint':
+      return pgBigint(colName, { mode: 'bigint' })
+    case 'boolean':
+      return boolean(colName)
+    case 'timestamp':
+      return timestamp(colName, { withTimezone: true })
+    case 'date':
+      return date(colName)
+    case 'enum':
+      return text(colName)
+    case 'jsonb':
+      return jsonb(colName)
+    case 'decimal':
+      if (meta.precision !== undefined) {
+        return numeric(colName, { precision: meta.precision.p, scale: meta.precision.s })
+      }
+      return numeric(colName)
+    case 'money': {
+      const p = meta.precision?.p ?? 18
+      const s = meta.precision?.s ?? 4
+      return numeric(colName, { precision: p, scale: s })
+    }
+    case 'pgLsn':
+      return pgLsnColumn(colName)
+    case 'custom':
+      return meta.customColumn
+    default:
+      throw new Error(`[pipework] Unknown field kind: ${meta.kind as string}`)
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Drizzle check constraint types
+function buildChecks(colName: string, meta: FieldMeta, checks: any[]): void {
+  if (meta.kind === 'custom' || meta.array) return
+
+  const isNumeric = meta.kind === 'integer' || meta.kind === 'serial' || meta.kind === 'bigint' || meta.kind === 'decimal' || meta.kind === 'money'
+  const isText = meta.kind === 'text'
+
+  if (isNumeric) {
+    if (meta.min !== undefined && meta.max !== undefined) {
+      checks.push(
+        check(`${colName}_range`, sql`${sql.raw(colName)} >= ${sql.raw(String(meta.min))} AND ${sql.raw(colName)} <= ${sql.raw(String(meta.max))}`),
+      )
+    } else if (meta.min !== undefined) {
+      checks.push(
+        check(`${colName}_min`, sql`${sql.raw(colName)} >= ${sql.raw(String(meta.min))}`),
+      )
+    } else if (meta.max !== undefined) {
+      checks.push(
+        check(`${colName}_max`, sql`${sql.raw(colName)} <= ${sql.raw(String(meta.max))}`),
+      )
+    }
+  }
+
+  if (isText) {
+    if (meta.min !== undefined && meta.max !== undefined) {
+      checks.push(
+        check(`${colName}_length`, sql`length(${sql.raw(colName)}) >= ${sql.raw(String(meta.min))} AND length(${sql.raw(colName)}) <= ${sql.raw(String(meta.max))}`),
+      )
+    } else if (meta.min !== undefined) {
+      checks.push(
+        check(`${colName}_min_length`, sql`length(${sql.raw(colName)}) >= ${sql.raw(String(meta.min))}`),
+      )
+    } else if (meta.max !== undefined) {
+      checks.push(
+        check(`${colName}_max_length`, sql`length(${sql.raw(colName)}) <= ${sql.raw(String(meta.max))}`),
+      )
+    }
+  }
+
+  if (meta.kind === 'enum' && meta.enumValues !== undefined && meta.enumValues.length > 0) {
+    const escaped = meta.enumValues.map(v => `'${v.replace(/'/g, "''")}'`)
+    checks.push(
+      check(`${colName}_enum`, sql`${sql.raw(colName)} IN (${sql.raw(escaped.join(', '))})`),
+    )
+  }
+}