effect-qb 0.16.0 → 0.19.0

package/src/postgres.ts

@@ -1,23 +1,21 @@
-/** Postgres-specialized column-definition DSL. */
-export * as Column from "./postgres/column.js"
+/** Postgres-specific column extensions. Portable columns are exported from `effect-qb`. */
+export * as Column from "./postgres/column-extension.js"
 /** Postgres datatype witnesses and coercion families. */
 export * as Datatypes from "./postgres/datatypes/index.js"
 /** Postgres SQLSTATE catalog and error normalization helpers. */
 export * as Errors from "./postgres/errors/index.js"
-/** Shared scalar SQL interfaces and DB-type descriptors. */
-export * as Scalar from "./internal/scalar.js"
 /** Postgres cast helpers. */
 export { cast as Cast } from "./postgres/cast.js"
-/** Postgres-specialized SQL function expressions. */
+/** Postgres-specific SQL function expressions. Portable functions are exported from the root package. */
 export * as Function from "./postgres/function/index.js"
 /** Postgres-specialized JSON expression helpers. */
 export * as Json from "./postgres/json.js"
+/** Postgres jsonb-only expression helpers. */
+export * as Jsonb from "./postgres/jsonb.js"
 /** Postgres-specialized typed query execution contracts. */
 export * as Executor from "./postgres/executor.js"
-/** Shared logical row-set interfaces. */
-export * as RowSet from "./internal/row-set.js"
-/** Postgres-specialized query-construction DSL. */
-export * as Query from "./postgres/query.js"
+/** Postgres-specific query helpers. Portable queries are exported from the root package. */
+export * as Query from "./postgres/query-extension.js"
 /** Postgres database-type constructors for casts and typed references. */
 export { type as Type } from "./postgres/type.js"
 /** Postgres normalized table/enum metadata helpers. */
@@ -25,12 +23,12 @@ export * as Metadata from "./postgres/metadata.js"
 /** Postgres schema-expression helpers for DDL-only metadata. */
 export * as SchemaExpression from "./postgres/schema-expression.js"
 /** Postgres schema-scoped table and enum builder helpers. */
-export { schema } from "./postgres/schema.js"
+export * as Schema from "./postgres/schema.js"
 export type { SchemaNamespace } from "./postgres/schema.js"
 /** Postgres enum and sequence definition helpers. */
 export { enumType as enum, sequence } from "./postgres/schema-management.js"
 export type { EnumDefinition, SequenceDefinition } from "./postgres/schema-management.js"
-/** Postgres-specialized table-definition DSL. */
+/** Postgres-specific table-option extensions. Portable tables are exported from `effect-qb`. */
 export * as Table from "./postgres/table.js"
 /** Postgres-specialized built-in renderer entrypoint. */
 export * as Renderer from "./postgres/renderer.js"

package/src/sqlite/column-extension.ts

@@ -0,0 +1,3 @@
+export { custom } from "./column.js"
+
+export type { Any, AnyBound } from "./column.js"

package/src/sqlite/column.ts

@@ -0,0 +1,127 @@
+import * as Schema from "effect/Schema"
+
+import * as BaseColumn from "../internal/column.js"
+import { makeColumnDefinition, type AnyColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import { enrichDbType } from "../internal/datatypes/enrich.js"
+import {
+  DecimalStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type DecimalString,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../internal/runtime/value.js"
+import { sqliteDatatypes } from "./datatypes/index.js"
+
+const primitive = <Type, Db extends Expression.DbType.Any>(
+  schema: Schema.Schema<Type, any, any>,
+  dbType: Db
+): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
+    dbType,
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined
+  })
+
+const renderNumericDdlType = (
+  kind: string,
+  options?: BaseColumn.NumericOptions
+): string | undefined => {
+  if (options === undefined || options.precision === undefined) {
+    return undefined
+  }
+  return options.scale === undefined
+    ? `${kind}(${options.precision})`
+    : `${kind}(${options.precision},${options.scale})`
+}
+
+export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+  schema: SchemaType,
+  dbType: Db
+) =>
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: enrichDbType(sqliteDatatypes, dbType),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const uuid = () => primitive(Schema.UUID, sqliteDatatypes.uuid())
+export const text = () => primitive(Schema.String, sqliteDatatypes.text())
+export const int = () => primitive(Schema.Int, sqliteDatatypes.int())
+export const number = (options?: BaseColumn.NumericOptions) =>
+  makeColumnDefinition(DecimalStringSchema, {
+    dbType: sqliteDatatypes.decimal(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: renderNumericDdlType("decimal", options),
+    identity: undefined
+  })
+export const boolean = () => primitive(Schema.Boolean, sqliteDatatypes.boolean())
+export const date = () => primitive(LocalDateStringSchema, sqliteDatatypes.date())
+export const time = () => primitive(LocalTimeStringSchema, sqliteDatatypes.time())
+export const datetime = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.datetime())
+export const timestamp = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.timestamp())
+export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: { ...sqliteDatatypes.json(), variant: "json" } as Expression.DbType.Json<"sqlite", "json">,
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const nullable = BaseColumn.nullable
+export const brand = BaseColumn.brand
+export const primaryKey = BaseColumn.primaryKey
+type UniqueColumn<Column extends AnyColumnDefinition> = ReturnType<typeof BaseColumn.unique<Column>>
+
+type SqliteUniqueOptions = {
+  readonly name?: string
+  readonly nullsNotDistinct?: never
+  readonly deferrable?: never
+  readonly initiallyDeferred?: never
+}
+
+type NonEmptyOptionNameInput<Options> = Options extends { readonly name: infer Name extends string }
+  ? NonEmptyStringInput<Name> extends never ? never : unknown
+  : unknown
+
+type UniqueModifier = {
+  <Column extends AnyColumnDefinition>(column: Column): UniqueColumn<Column>
+  readonly options: <const Options extends SqliteUniqueOptions>(
+    options: Options & NonEmptyOptionNameInput<Options>
+  ) => <Column extends AnyColumnDefinition>(column: Column) => UniqueColumn<Column>
+}
+
+export const unique = BaseColumn.unique as UniqueModifier
+const default_ = BaseColumn.default_
+export const generated = BaseColumn.generated
+export const driverValueMapping = BaseColumn.driverValueMapping
+export const references = BaseColumn.references
+export const schema = BaseColumn.schema
+export { default_ as default }
+
+export type Any = BaseColumn.Any
+export type AnyBound = BaseColumn.AnyBound

package/src/sqlite/datatypes/index.ts

@@ -0,0 +1,80 @@
+import type { DatatypeModule } from "../../internal/datatypes/define.js"
+import type * as Expression from "../../internal/scalar.js"
+import type { NonEmptyStringInput } from "../../internal/table-options.js"
+import { sqliteDatatypeFamilies, sqliteDatatypeKinds } from "./spec.js"
+
+const withMetadata = <Kind extends keyof typeof sqliteDatatypeKinds & string>(
+  kind: Kind
+): Expression.DbType.Base<"sqlite", Kind> => {
+  const kindSpec = sqliteDatatypeKinds[kind]
+  const familySpec = sqliteDatatypeFamilies[kindSpec.family as keyof typeof sqliteDatatypeFamilies]
+  return {
+    dialect: "sqlite",
+    kind,
+    family: kindSpec.family,
+    runtime: kindSpec.runtime,
+    compareGroup: familySpec?.compareGroup,
+    castTargets: familySpec?.castTargets,
+    traits: familySpec?.traits
+  }
+}
+
+const sqliteDatatypeModule = {
+  custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => ({
+    dialect: "sqlite",
+    kind: kind as Kind
+  }),
+  uuid: () => ({
+    dialect: "sqlite",
+    kind: "uuid",
+    family: "uuid",
+    runtime: "string",
+    compareGroup: "uuid",
+    castTargets: ["uuid", "char", "varchar", "text"],
+    traits: {
+      textual: true
+    }
+  })
+} as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"sqlite", string>>
+
+for (const kind of Object.keys(sqliteDatatypeKinds)) {
+  sqliteDatatypeModule[kind] = () => withMetadata(kind as keyof typeof sqliteDatatypeKinds & string)
+}
+
+type SqliteUuidWitness = Expression.DbType.Base<"sqlite", "uuid"> & {
+  readonly family: "uuid"
+  readonly runtime: "string"
+  readonly compareGroup: "uuid"
+  readonly castTargets: readonly ["uuid", "char", "varchar", "text"]
+  readonly traits: {
+    readonly textual: true
+  }
+}
+
+type SqliteJsonWitness = Expression.DbType.Base<"sqlite", "json"> & {
+  readonly family: "json"
+  readonly runtime: "json"
+  readonly compareGroup: "json"
+  readonly castTargets: readonly ["json", "text"]
+  readonly driverValueMapping: {
+    readonly toDriver: (value: unknown) => unknown
+  }
+}
+
+sqliteDatatypeModule.json = () => ({
+  ...withMetadata("json"),
+  driverValueMapping: {
+    toDriver: (value: unknown) => JSON.stringify(value)
+  }
+}) as SqliteJsonWitness
+
+export const sqliteDatatypes = sqliteDatatypeModule as DatatypeModule<
+  "sqlite",
+  typeof sqliteDatatypeKinds,
+  typeof sqliteDatatypeFamilies
+> & {
+  readonly uuid: () => SqliteUuidWitness
+  readonly json: () => SqliteJsonWitness
+}
+
+export type SqliteDatatypeModule = typeof sqliteDatatypes

package/src/sqlite/datatypes/spec.ts

@@ -0,0 +1,98 @@
+import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+
+export const sqliteDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  integer: {
+    compareGroup: "numeric",
+    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  real: {
+    compareGroup: "numeric",
+    castTargets: ["real", "numeric", "integer", "text", "boolean"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "integer", "numeric", "text"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  blob: {
+    compareGroup: "blob",
+    castTargets: ["blob", "text"],
+    traits: {}
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {}
+  }
+} as const satisfies Record<string, DatatypeFamilySpec>
+
+export const sqliteDatatypeKinds = {
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  clob: { family: "text", runtime: "string" },
+  int: { family: "integer", runtime: "number" },
+  integer: { family: "integer", runtime: "number" },
+  bigint: { family: "integer", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  real: { family: "real", runtime: "number" },
+  double: { family: "real", runtime: "number" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "datetime", runtime: "localDateTime" },
+  json: { family: "json", runtime: "json" },
+  blob: { family: "blob", runtime: "bytes" }
+} as const satisfies Record<string, DatatypeKindSpec>
+
+export type SqliteDatatypeFamily = keyof typeof sqliteDatatypeFamilies
+export type SqliteDatatypeKind = keyof typeof sqliteDatatypeKinds

package/src/sqlite/errors/catalog.ts

@@ -0,0 +1,103 @@
+export const sqliteErrorCategories = {
+  sqlite: "sqlite"
+} as const
+
+export type SqliteErrorCategory = keyof typeof sqliteErrorCategories
+
+type SqliteErrorDescriptorShape<Symbol extends string = string> = {
+  readonly category: "sqlite"
+  readonly number: `${number}`
+  readonly symbol: Symbol
+  readonly tag: `@sqlite/${Lowercase<Symbol>}`
+  readonly messageTemplate: string
+}
+
+const descriptor = <Symbol extends string>(
+  number: `${number}`,
+  symbol: Symbol,
+  messageTemplate: string
+): SqliteErrorDescriptorShape<Symbol> => ({
+  category: "sqlite",
+  number,
+  symbol,
+  tag: `@sqlite/${symbol.toLowerCase()}` as `@sqlite/${Lowercase<Symbol>}`,
+  messageTemplate
+})
+
+export const sqliteErrorCatalogBySymbol = {
+  SQLITE_ERROR: descriptor("1", "SQLITE_ERROR", "SQL error or missing database"),
+  SQLITE_INTERNAL: descriptor("2", "SQLITE_INTERNAL", "Internal SQLite logic error"),
+  SQLITE_PERM: descriptor("3", "SQLITE_PERM", "Access permission denied"),
+  SQLITE_ABORT: descriptor("4", "SQLITE_ABORT", "Callback routine requested an abort"),
+  SQLITE_BUSY: descriptor("5", "SQLITE_BUSY", "Database file is locked"),
+  SQLITE_LOCKED: descriptor("6", "SQLITE_LOCKED", "Database table is locked"),
+  SQLITE_NOMEM: descriptor("7", "SQLITE_NOMEM", "Out of memory"),
+  SQLITE_READONLY: descriptor("8", "SQLITE_READONLY", "Attempt to write a readonly database"),
+  SQLITE_INTERRUPT: descriptor("9", "SQLITE_INTERRUPT", "Operation terminated by sqlite3_interrupt"),
+  SQLITE_IOERR: descriptor("10", "SQLITE_IOERR", "Disk I/O error"),
+  SQLITE_CORRUPT: descriptor("11", "SQLITE_CORRUPT", "Database disk image is malformed"),
+  SQLITE_NOTFOUND: descriptor("12", "SQLITE_NOTFOUND", "Unknown opcode"),
+  SQLITE_FULL: descriptor("13", "SQLITE_FULL", "Insertion failed because database is full"),
+  SQLITE_CANTOPEN: descriptor("14", "SQLITE_CANTOPEN", "Unable to open the database file"),
+  SQLITE_PROTOCOL: descriptor("15", "SQLITE_PROTOCOL", "Database lock protocol error"),
+  SQLITE_EMPTY: descriptor("16", "SQLITE_EMPTY", "Database is empty"),
+  SQLITE_SCHEMA: descriptor("17", "SQLITE_SCHEMA", "Database schema changed"),
+  SQLITE_TOOBIG: descriptor("18", "SQLITE_TOOBIG", "String or blob exceeds size limit"),
+  SQLITE_CONSTRAINT: descriptor("19", "SQLITE_CONSTRAINT", "Constraint violation"),
+  SQLITE_MISMATCH: descriptor("20", "SQLITE_MISMATCH", "Data type mismatch"),
+  SQLITE_MISUSE: descriptor("21", "SQLITE_MISUSE", "Library used incorrectly"),
+  SQLITE_NOLFS: descriptor("22", "SQLITE_NOLFS", "Uses OS features not supported on host"),
+  SQLITE_AUTH: descriptor("23", "SQLITE_AUTH", "Authorization denied"),
+  SQLITE_FORMAT: descriptor("24", "SQLITE_FORMAT", "Auxiliary database format error"),
+  SQLITE_RANGE: descriptor("25", "SQLITE_RANGE", "Bind parameter index out of range"),
+  SQLITE_NOTADB: descriptor("26", "SQLITE_NOTADB", "File is not a database"),
+  SQLITE_NOTICE: descriptor("27", "SQLITE_NOTICE", "Notifications from sqlite3_log"),
+  SQLITE_WARNING: descriptor("28", "SQLITE_WARNING", "Warnings from sqlite3_log"),
+  SQLITE_ROW: descriptor("100", "SQLITE_ROW", "sqlite3_step has another row ready"),
+  SQLITE_DONE: descriptor("101", "SQLITE_DONE", "sqlite3_step has finished executing"),
+  SQLITE_BUSY_RECOVERY: descriptor("261", "SQLITE_BUSY_RECOVERY", "Database is busy recovering"),
+  SQLITE_BUSY_SNAPSHOT: descriptor("517", "SQLITE_BUSY_SNAPSHOT", "Database snapshot is busy"),
+  SQLITE_BUSY_TIMEOUT: descriptor("773", "SQLITE_BUSY_TIMEOUT", "Blocking POSIX advisory lock timed out"),
+  SQLITE_CONSTRAINT_CHECK: descriptor("275", "SQLITE_CONSTRAINT_CHECK", "CHECK constraint failed"),
+  SQLITE_CONSTRAINT_FOREIGNKEY: descriptor("787", "SQLITE_CONSTRAINT_FOREIGNKEY", "FOREIGN KEY constraint failed"),
+  SQLITE_CONSTRAINT_NOTNULL: descriptor("1299", "SQLITE_CONSTRAINT_NOTNULL", "NOT NULL constraint failed"),
+  SQLITE_CONSTRAINT_PRIMARYKEY: descriptor("1555", "SQLITE_CONSTRAINT_PRIMARYKEY", "PRIMARY KEY constraint failed"),
+  SQLITE_CONSTRAINT_UNIQUE: descriptor("2067", "SQLITE_CONSTRAINT_UNIQUE", "UNIQUE constraint failed")
+} as const
+
+export type SqliteErrorSymbol = keyof typeof sqliteErrorCatalogBySymbol
+
+export type SqliteErrorDescriptor = (typeof sqliteErrorCatalogBySymbol)[SqliteErrorSymbol]
+
+export type SqliteErrorNumber = SqliteErrorDescriptor["number"]
+
+export type SqliteErrorTag = SqliteErrorDescriptor["tag"]
+
+const sqliteErrorDescriptors = Object.values(sqliteErrorCatalogBySymbol)
+
+export const sqliteErrorCatalogByNumber = sqliteErrorDescriptors.reduce(
+  (acc, entry) => ({
+    ...acc,
+    [entry.number]: [...(acc[entry.number as SqliteErrorNumber] ?? []), entry]
+  }),
+  {} as Record<SqliteErrorNumber, readonly SqliteErrorDescriptor[]>
+)
+
+export const isSqliteErrorSymbol = (value: string): value is SqliteErrorSymbol =>
+  value in sqliteErrorCatalogBySymbol
+
+export const isSqliteErrorNumber = (value: string): value is SqliteErrorNumber =>
+  value in sqliteErrorCatalogByNumber
+
+export const getSqliteErrorDescriptor = (
+  symbol: SqliteErrorSymbol
+): SqliteErrorDescriptor => sqliteErrorCatalogBySymbol[symbol]
+
+export const findSqliteErrorDescriptorsByNumber = (
+  number: SqliteErrorNumber
+): readonly SqliteErrorDescriptor[] => sqliteErrorCatalogByNumber[number] ?? []
+
+export const findSqliteErrorDescriptorsByNumberLoose = (
+  number: string
+): readonly SqliteErrorDescriptor[] | undefined =>
+  isSqliteErrorNumber(number) ? sqliteErrorCatalogByNumber[number] : undefined

package/src/sqlite/errors/fields.ts

@@ -0,0 +1,19 @@
+/** Common SQLite driver error fields surfaced by the normalizer when present. */
+export interface SqliteErrorFields {
+  readonly code?: string
+  readonly errno?: number
+  readonly sqlState?: string
+  readonly sqlMessage?: string
+  readonly fatal?: boolean
+  readonly sql?: string
+  readonly syscall?: string
+  readonly address?: string
+  readonly port?: number
+  readonly hostname?: string
+}
+
+/** Rendered SQL context attached to normalized SQLite execution failures. */
+export interface SqliteQueryContext {
+  readonly sql: string
+  readonly params: readonly unknown[]
+}

package/src/sqlite/errors/index.ts

@@ -0,0 +1,19 @@
+export * from "./catalog.js"
+export * from "./fields.js"
+export * from "./normalize.js"
+export * from "./requirements.js"
+export * from "./types.js"
+
+export {
+  findSqliteErrorDescriptorsByNumber as findSqliteErrorDescriptorsByNumber,
+  getSqliteErrorDescriptor as getSqliteErrorDescriptor,
+  isSqliteErrorNumber as isSqliteErrorNumber,
+  isSqliteErrorSymbol as isSqliteErrorSymbol
+} from "./catalog.js"
+
+export {
+  hasNumber as hasErrorNumber,
+  hasSymbol as hasErrorSymbol,
+  isSqliteErrorLike as isSqliteErrorLike,
+  normalizeSqliteDriverError as normalizeSqliteDriverError
+} from "./normalize.js"