effect-qb 0.16.0 → 0.19.0

package/src/sqlite/internal/renderer.ts

@@ -0,0 +1,51 @@
+import * as Query from "../../internal/query.js"
+import type * as Expression from "../../internal/scalar.js"
+import type * as Casing from "../../internal/casing.js"
+import { type RenderState } from "../../internal/dialect.js"
+import { sqliteDialect } from "./dialect.js"
+import { type Projection } from "../../internal/projections.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
+
+/**
+ * Internal rendered-query payload produced by the built-in SQLite renderer.
+ */
+export interface SqliteRenderResult {
+  readonly sql: string
+  readonly params: readonly unknown[]
+  readonly projections: readonly Projection[]
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
+export interface SqliteRenderOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
+}
+
+/**
+ * Renders the current query AST into SQLite-shaped SQL plus bind parameters.
+ */
+export const renderSqlitePlan = <PlanValue extends Query.Plan.Any>(
+  plan: Query.DialectCompatiblePlan<PlanValue, "sqlite">,
+  options: SqliteRenderOptions = {}
+): SqliteRenderResult => {
+  const state: RenderState = {
+    params: [],
+    valueMappings: options.valueMappings,
+    casing: options.casing,
+    ctes: [],
+    cteNames: new Set<string>(),
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
+  }
+  const rendered = renderQueryAst(
+    Query.getAst(plan as Query.Plan.Any) as any,
+    state,
+    sqliteDialect
+  )
+  return {
+    sql: rendered.sql,
+    params: state.params,
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
+  }
+}

package/src/sqlite/json.ts

@@ -0,0 +1,39 @@
+/** SQLite JSON expression helpers. */
+export { json } from "./internal/dsl.js"
+import { json } from "./internal/dsl.js"
+
+export const key = json.key
+export const index = json.index
+export const wildcard = json.wildcard
+export const slice = json.slice
+export const descend = json.descend
+export const path = json.path
+export const get = json.get
+export const access = json.access
+export const traverse = json.traverse
+export const text = json.text
+export const accessText = json.accessText
+export const traverseText = json.traverseText
+export const contains = json.contains
+export const containedBy = json.containedBy
+export const hasKey = json.hasKey
+export const keyExists = json.keyExists
+export const hasAnyKeys = json.hasAnyKeys
+export const hasAllKeys = json.hasAllKeys
+export const delete_ = json.delete
+export { delete_ as delete }
+export const remove = json.remove
+export const set = json.set
+export const insert = json.insert
+export const concat = json.concat
+export const merge = json.merge
+export const buildObject = json.buildObject
+export const buildArray = json.buildArray
+export const toJson = json.toJson
+export const toJsonb = json.toJsonb
+export const typeOf = json.typeOf
+export const length = json.length
+export const keys = json.keys
+export const stripNulls = json.stripNulls
+export const pathExists = json.pathExists
+export const pathMatch = json.pathMatch

package/src/sqlite/query-extension.ts

@@ -0,0 +1,2 @@
+/** SQLite-only conflict-target helpers. Portable query builders are exported from the root package. */
+export { onConflict } from "./query.js"

package/src/sqlite/query.ts

@@ -0,0 +1,196 @@
+import {
+  type AnyTableFunctionSource,
+  type AnyUnnestSource,
+  type AnyValuesSource,
+  type CapabilitiesOfPlan,
+  type CompletePlan,
+  type DialectCompatiblePlan,
+  type DerivedSourceRequiredError,
+  type CteSource,
+  type EffectiveNullability,
+  type ExpressionInput,
+  type ExpressionOutput,
+  type GroupByInput,
+  type MergeCapabilities,
+  type MergeCapabilityTuple,
+  type HavingPredicateInput,
+  type OrderDirection,
+  type OutputOfSelection,
+  type MutationTargetLike,
+  type NumericExpressionInput,
+  type PredicateInput,
+  type QueryCapability,
+  type QueryPlan,
+  type QueryRequirement,
+  type SetCompatiblePlan,
+  type SetCompatibleRightPlan,
+  type SetOperator,
+  type QueryStatement,
+  type ResultRow,
+  type ResultRows,
+  type RuntimeResultRow,
+  type RuntimeResultRows,
+  type SchemaTableLike,
+  type SourceCapabilitiesOf,
+  type SourceRequiredOf,
+  type SourceRequirementError,
+  type StatementOfPlan,
+  type StringExpressionInput
+} from "../internal/query.js"
+import {
+  type PublicNonStructuredFromApi,
+  type PublicStructuredFromConstraint,
+  type PublicStructuredFromResult,
+  type as sqliteType,
+  values,
+  unnest,
+  select,
+  insert,
+  from as dslFrom
+} from "./internal/dsl.js"
+
+export {
+  literal,
+  column,
+  cast,
+  eq,
+  neq,
+  lt,
+  lte,
+  gt,
+  gte,
+  isNull,
+  isNotNull,
+  like,
+  ilike,
+  regexMatch,
+  regexIMatch,
+  regexNotMatch,
+  regexNotIMatch,
+  and,
+  or,
+  not,
+  all,
+  any,
+  case_ as case,
+  match,
+  in_ as in,
+  notIn,
+  between,
+  contains,
+  containedBy,
+  overlaps,
+  exists,
+  isDistinctFrom,
+  isNotDistinctFrom,
+  excluded,
+  as,
+  with_ as with,
+  withRecursive,
+  lateral,
+  scalar,
+  inSubquery,
+  compareAny,
+  compareAll,
+  generateSeries,
+  values,
+  unnest,
+  select,
+  returning,
+  onConflict,
+  insert,
+  update,
+  upsert,
+  delete_ as delete,
+  truncate,
+  merge,
+  transaction,
+  commit,
+  rollback,
+  savepoint,
+  rollbackTo,
+  releaseSavepoint,
+  createTable,
+  dropTable,
+  createIndex,
+  dropIndex,
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll,
+  where,
+  having,
+  innerJoin,
+  leftJoin,
+  rightJoin,
+  fullJoin,
+  crossJoin,
+  distinct,
+  distinctOn,
+  limit,
+  offset,
+  lock,
+  orderBy,
+  groupBy
+} from "./internal/dsl.js"
+import type * as Expression from "../internal/scalar.js"
+export { sqliteType as type }
+
+type SqliteMutationValueInput<Value> =
+  | Value
+  | Expression.Scalar<Value, Expression.DbType.Any, Expression.Nullability, "sqlite", Expression.ScalarKind, Expression.BindingId>
+
+export type MutationInputOf<Shape> = {
+  readonly [K in keyof Shape]: SqliteMutationValueInput<Shape[K]>
+}
+
+type StructuredSource = AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource
+
+type StructuredFromApi = <CurrentSource extends StructuredSource>(
+  source: CurrentSource
+) => <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+  plan: PlanValue & PublicStructuredFromConstraint<PlanValue, CurrentSource, "sqlite">
+) => PublicStructuredFromResult<PlanValue, CurrentSource, "sqlite">
+
+export const from: StructuredFromApi & PublicNonStructuredFromApi = dslFrom as StructuredFromApi & PublicNonStructuredFromApi
+
+export type {
+  CapabilitiesOfPlan,
+  CompletePlan,
+  DialectCompatiblePlan,
+  DerivedSourceRequiredError,
+  CteSource,
+  EffectiveNullability,
+  ExpressionInput,
+  ExpressionOutput,
+  GroupByInput,
+  MergeCapabilities,
+  MergeCapabilityTuple,
+  HavingPredicateInput,
+  OrderDirection,
+  OutputOfSelection,
+  MutationTargetLike,
+  NumericExpressionInput,
+  PredicateInput,
+  QueryCapability,
+  QueryPlan,
+  QueryStatement,
+  QueryRequirement,
+  SetCompatiblePlan,
+  SetCompatibleRightPlan,
+  SetOperator,
+  ResultRow,
+  ResultRows,
+  RuntimeResultRow,
+  RuntimeResultRows,
+  SchemaTableLike,
+  SourceCapabilitiesOf,
+  SourceRequiredOf,
+  SourceRequirementError,
+  StatementOfPlan,
+  StringExpressionInput
+}
+
+export { union_query_capabilities } from "../internal/query.js"

package/src/sqlite/renderer.ts

@@ -0,0 +1,51 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
+import * as CoreRenderer from "../internal/renderer.js"
+import * as Casing from "../internal/casing.js"
+import type * as Expression from "../internal/scalar.js"
+import type { SqliteDatatypeFamily, SqliteDatatypeKind } from "./datatypes/spec.js"
+import { renderSqlitePlan } from "./internal/renderer.js"
+
+/** SQLite-specialized rendered query shape. */
+export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "sqlite">
+/** Extracts the row type carried by a SQLite rendered query. */
+export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
+/** SQLite-specialized renderer contract. */
+export type Renderer = CoreRenderer.Renderer<"sqlite"> & Pipeable & {
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => Renderer
+}
+
+export type ValueMappings = Expression.DriverValueMappingsFor<SqliteDatatypeKind | "uuid", SqliteDatatypeFamily | "uuid">
+
+export interface MakeOptions {
+  readonly valueMappings?: ValueMappings
+  readonly casing?: Casing.Options
+}
+
+export { TypeId } from "../internal/renderer.js"
+export type { Projection } from "../internal/renderer.js"
+
+const RendererProto = {
+  pipe(this: Pipeable) {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** Creates the built-in SQLite renderer. */
+export const make = (options: MakeOptions = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, options))
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [Casing.TypeId]: {
+      casing: options.casing
+    },
+    withCasing: (override: Casing.Options) =>
+      make({
+        ...options,
+        casing: Casing.merge(options.casing, override)
+      })
+  }) as Renderer
+}
+
+/** Shared built-in SQLite renderer instance. */
+export const sqlite = make()

package/src/sqlite.ts

@@ -0,0 +1,14 @@
+/** SQLite-specific column extensions. Portable columns are exported from `effect-qb`. */
+export * as Column from "./sqlite/column-extension.js"
+/** SQLite datatype witnesses and coercion families. */
+export * as Datatypes from "./sqlite/datatypes/index.js"
+/** SQLite error catalog and error normalization helpers. */
+export * as Errors from "./sqlite/errors/index.js"
+/** SQLite-specialized JSON expression helpers. */
+export * as Json from "./sqlite/json.js"
+/** SQLite-specialized typed query execution contracts. */
+export * as Executor from "./sqlite/executor.js"
+/** SQLite-specific query helpers. Portable queries are exported from the root package. */
+export * as Query from "./sqlite/query-extension.js"
+/** SQLite-specialized built-in renderer entrypoint. */
+export * as Renderer from "./sqlite/renderer.js"

package/src/standard/column.ts

@@ -0,0 +1,163 @@
+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 {
+  BigIntStringSchema,
+  DecimalStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type BigIntString,
+  type DecimalString,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../internal/runtime/value.js"
+import { standardDatatypes } 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})`
+}
+
+const boundedString = (length?: number): Schema.Schema<string> =>
+  length === undefined
+    ? Schema.String
+    : Schema.String.pipe(Schema.maxLength(length))
+
+const finiteNumber = Schema.Number.pipe(Schema.finite())
+
+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(standardDatatypes, dbType),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const uuid = () => primitive(Schema.UUID, standardDatatypes.uuid())
+export const text = () => primitive(Schema.String, standardDatatypes.text())
+export const varchar = (length?: number) =>
+  makeColumnDefinition(boundedString(length), {
+    dbType: standardDatatypes.varchar(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: length === undefined ? "varchar" : `varchar(${length})`,
+    identity: undefined
+  })
+export const char = (length = 1) =>
+  makeColumnDefinition(boundedString(length), {
+    dbType: standardDatatypes.char(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: `char(${length})`,
+    identity: undefined
+  })
+export const int = () => primitive(Schema.Int, standardDatatypes.int())
+export const bigint = () => primitive(BigIntStringSchema, standardDatatypes.bigint())
+export const number = (options?: BaseColumn.NumericOptions) =>
+  makeColumnDefinition(DecimalStringSchema, {
+    dbType: standardDatatypes.decimal(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: renderNumericDdlType("decimal", options),
+    identity: undefined
+  })
+export const real = () => primitive(finiteNumber, standardDatatypes.real())
+export const boolean = () => primitive(Schema.Boolean, standardDatatypes.boolean())
+export const date = () => primitive(LocalDateStringSchema, standardDatatypes.date())
+export const time = () => primitive(LocalTimeStringSchema, standardDatatypes.time())
+export const datetime = () => primitive(LocalDateTimeStringSchema, standardDatatypes.datetime())
+export const timestamp = () => primitive(LocalDateTimeStringSchema, standardDatatypes.timestamp())
+export const blob = () => primitive(Schema.Uint8ArrayFromSelf, standardDatatypes.blob())
+export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: { ...standardDatatypes.json(), variant: "json" } as Expression.DbType.Json<"standard", "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 StandardUniqueOptions = {
+  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 StandardUniqueOptions>(
+    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/standard/datatypes/index.ts

@@ -0,0 +1,83 @@
+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 { standardDatatypeFamilies, standardDatatypeKinds } from "./spec.js"
+
+const withMetadata = <Kind extends keyof typeof standardDatatypeKinds & string>(
+  kind: Kind
+): Expression.DbType.Base<"standard", Kind> => {
+  const kindSpec = standardDatatypeKinds[kind]
+  const familySpec = standardDatatypeFamilies[kindSpec.family as keyof typeof standardDatatypeFamilies]
+  return {
+    dialect: "standard",
+    kind,
+    family: kindSpec.family,
+    runtime: kindSpec.runtime,
+    compareGroup: familySpec?.compareGroup,
+    castTargets: familySpec?.castTargets,
+    traits: familySpec?.traits
+  }
+}
+
+const standardDatatypeModule = {
+  custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => ({
+    dialect: "standard",
+    kind: kind as Kind
+  }),
+  uuid: () => ({
+    dialect: "standard",
+    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<"standard", string>>
+
+for (const kind of Object.keys(standardDatatypeKinds)) {
+  standardDatatypeModule[kind] = () => withMetadata(kind as keyof typeof standardDatatypeKinds & string)
+}
+
+type StandardUuidWitness = Expression.DbType.Base<"standard", "uuid"> & {
+  readonly family: "uuid"
+  readonly runtime: "string"
+  readonly compareGroup: "uuid"
+  readonly castTargets: readonly ["uuid", "char", "varchar", "text"]
+  readonly traits: {
+    readonly textual: true
+  }
+}
+
+type StandardJsonWitness = Expression.DbType.Base<"standard", "json"> & {
+  readonly family: "json"
+  readonly runtime: "json"
+  readonly compareGroup: "json"
+  readonly castTargets: readonly ["json", "text"]
+  readonly driverValueMapping: {
+    readonly toDriver: (value: unknown) => unknown
+  }
+}
+
+standardDatatypeModule.json = () => ({
+  ...withMetadata("json"),
+  driverValueMapping: {
+    toDriver: (value: unknown) => JSON.stringify(value)
+  }
+}) as StandardJsonWitness
+
+export const standardDatatypes = {
+  ...(standardDatatypeModule as DatatypeModule<
+    "standard",
+    typeof standardDatatypeKinds,
+    typeof standardDatatypeFamilies
+  > & {
+    readonly uuid: () => StandardUuidWitness
+    readonly json: () => StandardJsonWitness
+  }),
+  float8: () => withMetadata("real")
+}
+
+export type StandardDatatypeModule = typeof standardDatatypes