sovrium 0.0.2

package/src/infrastructure/database/sql/sql-field-predicates.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import type { Fields } from '@/domain/models/app/table/fields'
+
+/**
+ * Check if field is a user reference field (created-by, updated-by, deleted-by)
+ * Used to determine if Better Auth users table is required
+ * Exported for use in schema-initializer
+ */
+export const isUserReferenceField = (field: Fields[number]): boolean =>
+  field.type === 'created-by' || field.type === 'updated-by' || field.type === 'deleted-by'
+
+/**
+ * Check if field is an auto-populated user reference field (created-by only)
+ * created-by is always NOT NULL because it's auto-populated on creation
+ * Note: updated-by is NOT included because it's only set during update (nullable until first update)
+ * Note: deleted-by is NOT included because it's only set during soft-delete (nullable)
+ */
+export const isAutoPopulatedUserField = (field: Fields[number]): boolean =>
+  field.type === 'created-by'
+
+/**
+ * Check if field is a user field (type: 'user')
+ * Used to generate FOREIGN KEY constraints to users table
+ * Exported for use in schema-initializer
+ */
+export const isUserField = (field: Fields[number]): boolean => field.type === 'user'
+
+/**
+ * Check if field is a relationship field (type: 'relationship')
+ * Used to generate FOREIGN KEY constraints to related tables
+ */
+export const isRelationshipField = (
+  field: Fields[number]
+): field is Fields[number] & { type: 'relationship'; relatedTable: string } =>
+  field.type === 'relationship' && 'relatedTable' in field && typeof field.relatedTable === 'string'
+
+/**
+ * Check if field is an auto-timestamp field (created-at, updated-at)
+ */
+export const isAutoTimestampField = (field: Fields[number]): boolean =>
+  field.type === 'created-at' || field.type === 'updated-at'
+
+/**
+ * Check if field should use SERIAL type
+ */
+export const shouldUseSerial = (field: Fields[number], isPrimaryKey: boolean): boolean =>
+  field.type === 'autonumber' || (field.type === 'integer' && isPrimaryKey)
+
+/**
+ * Check if field should be NOT NULL
+ * Auto-managed fields (created-at, updated-at, created-by) and required fields are NOT NULL
+ * Note: When hasAuthConfig is false, created-by becomes NULLABLE (NULL when no auth)
+ * Note: updated-by is always nullable because it's only set during update (NULL until first update)
+ * Note: deleted-by is always nullable because it's only set during soft-delete
+ * Exported for use in schema-migration-helpers for nullability change detection
+ *
+ * @param hasAuthConfig - Whether auth is configured (default true). When false, auto-populated
+ *   user fields (created-by) become nullable to support apps without authentication.
+ */
+export const isFieldNotNull = (
+  field: Fields[number],
+  isPrimaryKey: boolean,
+  hasAuthConfig: boolean = true
+): boolean => {
+  // Auto-managed timestamp fields are always NOT NULL (created-at, updated-at)
+  if (isAutoTimestampField(field)) return true
+  // Auto-populated user fields (created-by) are NOT NULL only when auth is configured
+  // updated-by is excluded because it's only set during update (nullable until first update)
+  // deleted-by is excluded because it's only populated during soft-delete
+  if (isAutoPopulatedUserField(field)) return hasAuthConfig
+  // Primary key fields are always NOT NULL
+  if (isPrimaryKey) return true
+  // Check required property
+  return 'required' in field && field.required === true
+}

package/src/infrastructure/database/sql/sql-generators.ts

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/**
+ * SQL Generators - PostgreSQL DDL Generation for Sovrium Tables
+ *
+ * This module coordinates SQL generation for table creation, constraints, and relationships.
+ * Implementation is split across focused modules:
+ * - sql-type-mappings.ts: Field type → PostgreSQL type conversions
+ * - sql-field-predicates.ts: Field type checking functions
+ * - sql-column-generators.ts: Column definition generation
+ * - sql-check-constraints.ts: CHECK constraint generation
+ * - sql-key-constraints.ts: UNIQUE, FOREIGN KEY, PRIMARY KEY constraints
+ * - sql-junction-tables.ts: Many-to-many relationship tables
+ */
+
+import {
+  generateArrayConstraints,
+  generateBarcodeConstraints,
+  generateColorConstraints,
+  generateCustomCheckConstraints,
+  generateEnumConstraints,
+  generateMultiSelectConstraints,
+  generateMultipleAttachmentsConstraints,
+  generateNumericConstraints,
+  generateProgressConstraints,
+  generateRichTextConstraints,
+  generateStatusConstraints,
+} from './sql-check-constraints'
+import {
+  generateCompositeUniqueConstraints,
+  generateForeignKeyConstraints,
+  generatePrimaryKeyConstraint,
+  generateUniqueConstraints,
+} from './sql-key-constraints'
+import type { Table } from '@/domain/models/app/table'
+
+// Re-export from sql-type-mappings
+export { mapFieldTypeToPostgres } from './sql-type-mappings'
+
+// Re-export from sql-field-predicates
+export {
+  isFieldNotNull,
+  isRelationshipField,
+  isUserField,
+  isUserReferenceField,
+} from './sql-field-predicates'
+
+// Re-export from sql-column-generators
+export { generateColumnDefinition } from './sql-column-generators'
+
+// Re-export from sql-key-constraints
+export { generateForeignKeyConstraints, generateUniqueConstraints } from './sql-key-constraints'
+
+// Re-export from sql-junction-tables
+export {
+  generateJunctionTableDDL,
+  generateJunctionTableName,
+  toSingular,
+} from './sql-junction-tables'
+
+/**
+ * Generate table constraints (CHECK constraints, UNIQUE constraints, FOREIGN KEY, primary key, etc.)
+ */
+export const generateTableConstraints = (
+  table: Table,
+  tableUsesView?: ReadonlyMap<string, boolean>,
+  skipForeignKeys?: boolean
+): readonly string[] => [
+  ...generateArrayConstraints(table.fields),
+  ...generateMultipleAttachmentsConstraints(table.fields),
+  ...generateNumericConstraints(table.fields),
+  ...generateProgressConstraints(table.fields),
+  ...generateEnumConstraints(table.fields),
+  ...generateMultiSelectConstraints(table.fields),
+  ...generateStatusConstraints(table.fields),
+  ...generateRichTextConstraints(table.fields),
+  ...generateBarcodeConstraints(table.fields),
+  ...generateColorConstraints(table.fields),
+  ...generateCustomCheckConstraints(table.constraints),
+  ...generatePrimaryKeyConstraint(table),
+  ...generateUniqueConstraints(table.name, table.fields),
+  ...generateCompositeUniqueConstraints(table),
+  ...(skipForeignKeys
+    ? []
+    : generateForeignKeyConstraints(table.name, table.fields, tableUsesView, table.foreignKeys)),
+]

package/src/infrastructure/database/sql/sql-junction-tables.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/**
+ * Generate junction table name for many-to-many relationship
+ * Format: {table1}_{table2} (source table first, related table second)
+ */
+export const generateJunctionTableName = (sourceTable: string, relatedTable: string): string =>
+  `${sourceTable}_${relatedTable}`
+
+/**
+ * Common irregular plural to singular mappings for table naming
+ * Used by toSingular() to handle irregular English plurals
+ */
+const IRREGULAR_PLURALS: Readonly<Record<string, string>> = {
+  people: 'person',
+  children: 'child',
+  men: 'man',
+  women: 'woman',
+  teeth: 'tooth',
+  feet: 'foot',
+  geese: 'goose',
+  mice: 'mouse',
+  dice: 'die',
+  oxen: 'ox',
+  indices: 'index',
+  matrices: 'matrix',
+  vertices: 'vertex',
+  analyses: 'analysis',
+  criteria: 'criterion',
+  phenomena: 'phenomenon',
+  data: 'datum',
+  media: 'medium',
+}
+
+/**
+ * Convert table name to singular form for junction table column naming
+ * Uses irregular plural mapping with fallback to 's' removal heuristic
+ */
+export const toSingular = (tableName: string): string =>
+  IRREGULAR_PLURALS[tableName] ?? (tableName.endsWith('s') ? tableName.slice(0, -1) : tableName)
+
+/**
+ * Generate CREATE TABLE statement for junction table (many-to-many relationship)
+ *
+ * Junction tables have:
+ * - Two foreign key columns: {sourceTable}_id, {relatedTable}_id (singular form)
+ * - Composite primary key on both columns
+ * - Foreign key constraints to both tables
+ */
+export const generateJunctionTableDDL = (
+  sourceTable: string,
+  relatedTable: string,
+  tableUsesView?: ReadonlyMap<string, boolean>
+): string => {
+  const junctionTableName = generateJunctionTableName(sourceTable, relatedTable)
+  const sourceColumnName = `${toSingular(sourceTable)}_id`
+  const relatedColumnName = `${toSingular(relatedTable)}_id`
+
+  // Determine actual table names (base tables if using views)
+  const sourceTableName =
+    tableUsesView?.get(sourceTable) === true ? `${sourceTable}_base` : sourceTable
+  const relatedTableName =
+    tableUsesView?.get(relatedTable) === true ? `${relatedTable}_base` : relatedTable
+
+  const columns = [
+    `${sourceColumnName} INTEGER NOT NULL`,
+    `${relatedColumnName} INTEGER NOT NULL`,
+    `PRIMARY KEY (${sourceColumnName}, ${relatedColumnName})`,
+    `CONSTRAINT ${junctionTableName}_${sourceColumnName}_fkey FOREIGN KEY (${sourceColumnName}) REFERENCES ${sourceTableName}(id)`,
+    `CONSTRAINT ${junctionTableName}_${relatedColumnName}_fkey FOREIGN KEY (${relatedColumnName}) REFERENCES ${relatedTableName}(id)`,
+  ]
+
+  return `CREATE TABLE IF NOT EXISTS ${junctionTableName} (\n  ${columns.join(',\n  ')}\n)`
+}

package/src/infrastructure/database/sql/sql-key-constraints.ts

@@ -0,0 +1,210 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { isRelationshipField, isUserField, shouldUseSerial } from './sql-field-predicates'
+import type { Table } from '@/domain/models/app/table'
+import type { Fields } from '@/domain/models/app/table/fields'
+
+/**
+ * Generate UNIQUE constraints for fields with unique property
+ * Uses PostgreSQL default naming convention: {table}_{column}_key
+ *
+ * NOTE: Geolocation fields are excluded because POINT type requires GiST index for UNIQUE,
+ * not btree. UNIQUE GiST indexes for geolocation fields are created separately in
+ * generateIndexStatements() in schema-initializer.ts
+ */
+export const generateUniqueConstraints = (
+  tableName: string,
+  fields: readonly Fields[number][]
+): readonly string[] =>
+  fields
+    .filter(
+      (field): field is Fields[number] & { unique: true } =>
+        'unique' in field && !!field.unique && field.type !== 'geolocation'
+    )
+    .map((field) => `CONSTRAINT ${tableName}_${field.name}_key UNIQUE (${field.name})`)
+
+/**
+ * Map onDelete/onUpdate values to PostgreSQL referential actions
+ *
+ * @param action - The referential action (cascade, set-null, restrict, etc.)
+ * @param clauseType - The type of clause (delete or update)
+ * @returns PostgreSQL referential action clause (e.g., " ON DELETE CASCADE")
+ */
+const mapReferentialAction = (
+  action: string | undefined,
+  clauseType: 'delete' | 'update'
+): string => {
+  if (!action) return ''
+  const upperAction = action.toUpperCase()
+  const validActions = ['CASCADE', 'SET NULL', 'SET DEFAULT', 'RESTRICT', 'NO ACTION']
+
+  // Map 'set-null' to 'SET NULL' for PostgreSQL compatibility
+  const normalizedAction = upperAction === 'SET-NULL' ? 'SET NULL' : upperAction
+
+  // Find matching PostgreSQL action
+  const postgresAction = validActions.find(
+    (valid) => valid.replace(' ', '-') === normalizedAction || valid === normalizedAction
+  )
+
+  if (!postgresAction) return ''
+
+  const clausePrefix = clauseType === 'delete' ? 'ON DELETE' : 'ON UPDATE'
+  return ` ${clausePrefix} ${postgresAction}`
+}
+
+/**
+ * Generate composite foreign key constraints from table.foreignKeys array
+ */
+const generateCompositeForeignKeyConstraints = (
+  compositeForeignKeys: readonly {
+    readonly name: string
+    readonly fields: readonly string[]
+    readonly referencedTable: string
+    readonly referencedFields: readonly string[]
+    readonly onDelete?: string
+    readonly onUpdate?: string
+  }[]
+): readonly string[] =>
+  compositeForeignKeys.map((fk) => {
+    const localFields = fk.fields.join(', ')
+    const referencedFields = fk.referencedFields.join(', ')
+    const onDeleteClause = mapReferentialAction(fk.onDelete, 'delete')
+    const onUpdateClause = mapReferentialAction(fk.onUpdate, 'update')
+
+    return `CONSTRAINT ${fk.name} FOREIGN KEY (${localFields}) REFERENCES ${fk.referencedTable}(${referencedFields})${onDeleteClause}${onUpdateClause}`
+  })
+
+/**
+ * Generate FOREIGN KEY constraint for relationship field
+ */
+const generateRelationshipConstraint = (
+  tableName: string,
+  field: Fields[number] & { readonly type: 'relationship'; readonly relatedTable: string },
+  tableUsesView?: ReadonlyMap<string, boolean>
+): string => {
+  const constraintName = `${tableName}_${field.name}_fkey`
+  // If the related table uses a VIEW (has lookup fields), reference the base table instead
+  const relatedTableName =
+    tableUsesView?.get(field.relatedTable) === true
+      ? `${field.relatedTable}_base`
+      : field.relatedTable
+
+  // Build referential actions (ON DELETE, ON UPDATE)
+  const onDeleteClause =
+    'onDelete' in field ? mapReferentialAction(field.onDelete as string | undefined, 'delete') : ''
+  const onUpdateClause =
+    'onUpdate' in field ? mapReferentialAction(field.onUpdate as string | undefined, 'update') : ''
+
+  // Use relatedField if specified, otherwise default to 'id'
+  const referencedColumn = 'relatedField' in field && field.relatedField ? field.relatedField : 'id'
+
+  return `CONSTRAINT ${constraintName} FOREIGN KEY (${field.name}) REFERENCES ${relatedTableName}(${referencedColumn})${onDeleteClause}${onUpdateClause}`
+}
+
+/**
+ * Generate FOREIGN KEY constraints for user fields, relationship fields, and composite foreign keys
+ * Exported for use in migration system to sync FK constraints
+ */
+export const generateForeignKeyConstraints = (
+  tableName: string,
+  fields: readonly Fields[number][],
+  tableUsesView?: ReadonlyMap<string, boolean>,
+  compositeForeignKeys?: readonly {
+    readonly name: string
+    readonly fields: readonly string[]
+    readonly referencedTable: string
+    readonly referencedFields: readonly string[]
+    readonly onDelete?: string
+    readonly onUpdate?: string
+  }[]
+): readonly string[] => {
+  // Generate foreign keys for user fields (type: 'user')
+  // References auth.user table (Better Auth users in dedicated auth schema)
+  const userFieldConstraints = fields.filter(isUserField).map((field) => {
+    const constraintName = `${tableName}_${field.name}_fkey`
+    return `CONSTRAINT ${constraintName} FOREIGN KEY (${field.name}) REFERENCES auth.user(id)`
+  })
+
+  // Generate foreign keys for relationship fields (type: 'relationship')
+  // Exclude one-to-many and many-to-many relationships as they don't create FK constraints on the parent side
+  const relationshipFieldConstraints = fields
+    .filter(isRelationshipField)
+    .filter((field) => {
+      // Only create FK for many-to-one relationships or relationships without explicit relationType
+      // Exclude one-to-many (FK in related table) and many-to-many (uses junction table)
+      return (
+        !('relationType' in field) ||
+        (field.relationType !== 'one-to-many' && field.relationType !== 'many-to-many')
+      )
+    })
+    .map((field) => generateRelationshipConstraint(tableName, field, tableUsesView))
+
+  // Foreign keys disabled for created-by/updated-by fields
+  // Blocked by: https://github.com/sovrium/sovrium/issues/3980
+  // Infrastructure ready - uncomment lines below when issue is resolved
+  const userReferenceConstraints: readonly string[] = []
+  // const userReferenceConstraints = fields
+  //   .filter(isUserReferenceField)
+  //   .map((field) => {
+  //     const constraintName = `${tableName}_${field.name}_fkey`
+  //     return `CONSTRAINT ${constraintName} FOREIGN KEY (${field.name}) REFERENCES auth.user(id)`
+  //   })
+
+  // Generate composite foreign key constraints
+  const compositeFKs = generateCompositeForeignKeyConstraints(compositeForeignKeys ?? [])
+
+  return [
+    ...userFieldConstraints,
+    ...relationshipFieldConstraints,
+    ...userReferenceConstraints,
+    ...compositeFKs,
+  ]
+}
+
+/**
+ * Generate primary key constraint if defined
+ * Skips single-field composite keys when the field is SERIAL (PRIMARY KEY is already inline)
+ * Note: Special field 'id' is automatically SERIAL, so PRIMARY KEY is inline
+ */
+export const generatePrimaryKeyConstraint = (table: Table): readonly string[] => {
+  if (table.primaryKey?.type === 'composite' && table.primaryKey.fields) {
+    // For single-field composite keys, check if the field is SERIAL (PRIMARY KEY already inline)
+    if (table.primaryKey.fields.length === 1) {
+      const pkFieldName = table.primaryKey.fields[0]
+      const pkField = table.fields.find((f) => f.name === pkFieldName)
+
+      // Special case: 'id' field is automatically SERIAL, PRIMARY KEY is inline
+      if (pkFieldName === 'id' && !pkField) {
+        // PRIMARY KEY is already inline in the automatic id column definition
+        return []
+      }
+
+      if (pkField && shouldUseSerial(pkField, true)) {
+        // PRIMARY KEY is already inline in the SERIAL column definition
+        return []
+      }
+    }
+    return [`PRIMARY KEY (${table.primaryKey.fields.join(', ')})`]
+  }
+  return []
+}
+
+/**
+ * Generate composite UNIQUE constraints from table.uniqueConstraints
+ * These are multi-column unique constraints (e.g., UNIQUE (email, tenant_id))
+ */
+export const generateCompositeUniqueConstraints = (table: Table): readonly string[] => {
+  if (!table.uniqueConstraints || table.uniqueConstraints.length === 0) {
+    return []
+  }
+
+  return table.uniqueConstraints.map((constraint) => {
+    const fields = constraint.fields.join(', ')
+    return `CONSTRAINT ${constraint.name} UNIQUE (${fields})`
+  })
+}

package/src/infrastructure/database/sql/sql-type-mappings.ts

@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import type { Fields } from '@/domain/models/app/table/fields'
+
+/**
+ * Field type to PostgreSQL type mapping
+ * Note: button field type is included for type safety but should not create database columns
+ */
+export const fieldTypeToPostgresMap: Record<string, string> = {
+  integer: 'INTEGER',
+  autonumber: 'INTEGER',
+  decimal: 'DECIMAL',
+  'single-line-text': 'VARCHAR(255)',
+  'long-text': 'TEXT',
+  email: 'VARCHAR(255)',
+  url: 'VARCHAR(255)',
+  'phone-number': 'VARCHAR(255)',
+  'rich-text': 'TEXT',
+  checkbox: 'BOOLEAN',
+  boolean: 'BOOLEAN', // Alias for checkbox (used in tests)
+  date: 'DATE',
+  datetime: 'TIMESTAMPTZ',
+  time: 'TIME',
+  'single-select': 'VARCHAR(255)',
+  status: 'VARCHAR(255)',
+  'multi-select': 'TEXT[]',
+  currency: 'DECIMAL',
+  percentage: 'DECIMAL',
+  rating: 'INTEGER',
+  duration: 'INTERVAL',
+  color: 'VARCHAR(7)',
+  progress: 'INTEGER',
+  json: 'JSONB',
+  geolocation: 'POINT',
+  barcode: 'VARCHAR(255)',
+  'single-attachment': 'VARCHAR(255)',
+  'multiple-attachments': 'JSONB',
+  relationship: 'INTEGER',
+  lookup: 'TEXT',
+  rollup: 'TEXT',
+  count: 'INTEGER',
+  formula: 'TEXT',
+  user: 'TEXT',
+  'created-by': 'TEXT',
+  'updated-by': 'TEXT',
+  'deleted-by': 'TEXT',
+  'created-at': 'TIMESTAMP',
+  'updated-at': 'TIMESTAMP',
+  'deleted-at': 'TIMESTAMP',
+  button: 'TEXT',
+}
+
+/**
+ * Map formula resultType to PostgreSQL type
+ */
+const formulaResultTypeMap: Record<string, string> = {
+  decimal: 'DECIMAL',
+  number: 'DECIMAL',
+  numeric: 'DECIMAL',
+  integer: 'INTEGER',
+  int: 'INTEGER',
+  boolean: 'BOOLEAN',
+  bool: 'BOOLEAN',
+  text: 'TEXT',
+  string: 'TEXT',
+  'text[]': 'TEXT[]',
+  'string[]': 'TEXT[]',
+  date: 'DATE',
+  datetime: 'TIMESTAMPTZ',
+  timestamp: 'TIMESTAMPTZ',
+}
+
+export const mapFormulaResultTypeToPostgres = (resultType: string | undefined): string => {
+  if (!resultType) return 'TEXT'
+  return formulaResultTypeMap[resultType.toLowerCase()] ?? 'TEXT'
+}
+
+/**
+ * Map field type to PostgreSQL column type
+ * Throws error if field type is not recognized
+ */
+export const mapFieldTypeToPostgres = (field: Fields[number]): string => {
+  if (field.type === 'array') {
+    const itemType = 'itemType' in field && field.itemType ? field.itemType : 'text'
+    return `${itemType.toUpperCase()}[]`
+  }
+
+  // Handle decimal/currency/percentage with precision
+  const numericTypesWithPrecision = ['decimal', 'currency', 'percentage']
+  if (numericTypesWithPrecision.includes(field.type) && 'precision' in field && field.precision) {
+    return `NUMERIC(${field.precision},2)`
+  }
+
+  const postgresType = fieldTypeToPostgresMap[field.type]
+  if (!postgresType) {
+    // eslint-disable-next-line functional/no-throw-statements -- Error is caught by Effect.try in table-operations.ts
+    throw new Error(`Unknown field type: ${field.type}`)
+  }
+
+  return postgresType
+}

package/src/infrastructure/database/sql/sql-utils.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/**
+ * Escape single quotes in SQL string literals to prevent SQL injection
+ * PostgreSQL escapes single quotes by doubling them: ' becomes ''
+ *
+ * Used across all SQL generators (view-generators, lookup-view-generators, sql-generators)
+ */
+export const escapeSqlString = (value: string): string => value.replace(/'/g, "''")
+
+/**
+ * Format a value for SQL interpolation with proper escaping
+ * Strings are escaped and quoted, numbers/booleans are used directly
+ */
+export const formatSqlValue = (value: unknown): string => {
+  if (typeof value === 'string') {
+    return `'${escapeSqlString(value)}'`
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value)
+  }
+  if (value === null) {
+    return 'NULL'
+  }
+  // For other types (objects, arrays), convert to JSON string
+  return `'${escapeSqlString(JSON.stringify(value))}'`
+}
+
+/**
+ * Generate SQL LIKE pattern with wildcards for pattern matching operators
+ * Automatically escapes the value to prevent SQL injection
+ */
+export const formatLikePattern = (
+  value: unknown,
+  pattern: 'contains' | 'startsWith' | 'endsWith'
+): string => {
+  const stringValue = typeof value === 'string' ? value : String(value)
+  const escaped = escapeSqlString(stringValue)
+
+  switch (pattern) {
+    case 'contains':
+      return `'%${escaped}%'`
+    case 'startsWith':
+      return `'${escaped}%'`
+    case 'endsWith':
+      return `'%${escaped}'`
+  }
+}

package/src/infrastructure/database/table-live-layers.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Layer } from 'effect'
+import { ActivityRepositoryLive } from './repositories/activity-repository-live'
+import { BatchRepositoryLive } from './repositories/batch-repository-live'
+import { CommentRepositoryLive } from './repositories/comment-repository-live'
+import { TableRepositoryLive } from './repositories/table-repository-live'
+
+/**
+ * Composite layer providing all table-related repository implementations
+ *
+ * Import this single layer in presentation routes to satisfy
+ * all table, batch, comment, and activity repository requirements.
+ *
+ * @example
+ * ```typescript
+ * runEffect(c, program.pipe(Effect.provide(TableLive)), schema)
+ * ```
+ */
+export const TableLive = Layer.mergeAll(
+  TableRepositoryLive,
+  BatchRepositoryLive,
+  CommentRepositoryLive,
+  ActivityRepositoryLive
+)