effect-qb 0.17.0 → 0.20.0

package/src/sqlite/internal/renderer.ts

@@ -1,9 +1,10 @@
 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 "./sql-expression-renderer.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
 
 /**
  * Internal rendered-query payload produced by the built-in SQLite renderer.
@@ -17,6 +18,7 @@ export interface SqliteRenderResult {
 
 export interface SqliteRenderOptions {
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
 }
 
 /**
@@ -29,9 +31,11 @@ export const renderSqlitePlan = <PlanValue extends Query.Plan.Any>(
   const state: RenderState = {
     params: [],
     valueMappings: options.valueMappings,
+    casing: options.casing,
     ctes: [],
     cteNames: new Set<string>(),
-    cteSources: new Map<string, unknown>()
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
   }
   const rendered = renderQueryAst(
     Query.getAst(plan as Query.Plan.Any) as any,

package/src/sqlite/json.ts

@@ -1,2 +1,8 @@
-/** SQLite JSON expression helpers. */
-export { json } from "./internal/dsl.js"
+/** SQLite-specific JSON expression helpers. Portable JSON helpers are exported from `effect-qb`. */
+import { json } from "./internal/dsl.js"
+
+export const insert = json.insert
+export const typeOf = json.typeOf
+export const length = json.length
+export const stripNulls = json.stripNulls
+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/renderer.ts

@@ -1,5 +1,9 @@
+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. */
@@ -7,18 +11,48 @@ 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">
+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?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
+}
+
+interface RendererState extends MakeOptions {
+  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. */
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, state))
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [Casing.TypeId]: {
+      casing: state.casing
+    },
+    withCasing: (override: Casing.Options) =>
+      makeWithState({
+        ...state,
+        casing: Casing.merge(state.casing, override)
+      })
+  }) as Renderer
+}
+
 /** Creates the built-in SQLite renderer. */
 export const make = (options: MakeOptions = {}): Renderer =>
-  CoreRenderer.make("sqlite", (plan) => renderSqlitePlan(plan, options))
+  makeWithState({ valueMappings: options.valueMappings })
 
 /** Shared built-in SQLite renderer instance. */
 export const sqlite = make()

package/src/sqlite/type.ts

@@ -0,0 +1,40 @@
+import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import {
+  pickDatatypeConstructors,
+  sqliteSpecificDatatypeKeys,
+  type SqliteSpecificDatatypeKey
+} from "../internal/datatypes/matrix.js"
+import { sqliteDatatypes } from "./datatypes/index.js"
+
+type SqliteSpecificDatatypes = Pick<typeof sqliteDatatypes, SqliteSpecificDatatypeKey>
+
+type SqliteTypeNamespace = SqliteSpecificDatatypes & {
+  readonly custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"sqlite", Kind>
+  readonly driverValueMapping: <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ) => Db
+}
+
+const custom = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Base<"sqlite", Kind> => ({
+  dialect: "sqlite",
+  kind: kind as Kind
+})
+
+const driverValueMapping = <Db extends Expression.DbType.Any>(
+  dbType: Db,
+  mapping: Expression.DriverValueMapping
+): Db => ({
+  ...dbType,
+  driverValueMapping: mapping
+})
+
+/** SQLite-only database-type constructors for casts and typed column references. */
+export const type: SqliteTypeNamespace = {
+  ...pickDatatypeConstructors(sqliteDatatypes, sqliteSpecificDatatypeKeys),
+  custom,
+  driverValueMapping
+}

package/src/sqlite.ts

@@ -1,22 +1,16 @@
-/** SQLite-specialized column-definition DSL. */
-export * as Column from "./sqlite/column.js"
+/** 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"
-/** Shared scalar SQL interfaces and DB-type descriptors. */
-export * as Scalar from "./internal/scalar.js"
-/** SQLite-specialized SQL function expressions. */
-export * as Function from "./sqlite/function/index.js"
-/** SQLite-specialized JSON expression helpers. */
+/** SQLite-specific JSON expression helpers. Portable JSON helpers are exported from the root package. */
 export * as Json from "./sqlite/json.js"
 /** SQLite-specialized typed query execution contracts. */
 export * as Executor from "./sqlite/executor.js"
-/** Shared logical row-set interfaces. */
-export * as RowSet from "./internal/row-set.js"
-/** SQLite-specialized query-construction DSL. */
-export * as Query from "./sqlite/query.js"
-/** SQLite-specialized table-definition DSL. */
-export * as Table from "./sqlite/table.js"
+/** SQLite-specific query helpers. Portable queries are exported from the root package. */
+export * as Query from "./sqlite/query-extension.js"
+/** SQLite-only database-type constructors for casts and typed references. */
+export { type as Type } from "./sqlite/type.js"
 /** SQLite-specialized built-in renderer entrypoint. */
 export * as Renderer from "./sqlite/renderer.js"

package/src/standard/cast.ts

@@ -0,0 +1,113 @@
+import type * as ExpressionAst from "../internal/expression-ast.js"
+import type { CastTargetError } from "../internal/coercion/errors.js"
+import type { RuntimeOfDbType } from "../internal/coercion/analysis.js"
+import type { CanCastDbType } from "../internal/coercion/rules.js"
+import type { FamilyOfDbType } from "../internal/datatypes/lookup.js"
+import type { ExpressionInput } from "../internal/query.js"
+import type * as Expression from "../internal/scalar.js"
+import { cast as standardCast } from "../internal/standard-dsl.js"
+import type { standardDatatypes } from "./datatypes/index.js"
+import type { standardDatatypeFamilies } from "./datatypes/spec.js"
+
+type CastInput = ExpressionInput
+type CastTarget = Expression.DbType.Any
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type StandardNullDb = Expression.DbType.Base<"standard", "null"> & {
+  readonly family: "null"
+  readonly runtime: "unknown"
+  readonly compareGroup: "null"
+  readonly castTargets: typeof standardDatatypeFamilies.null.castTargets
+  readonly traits: {}
+}
+
+type LiteralDbType<Value> =
+  Value extends string ? ReturnType<typeof standardDatatypes.text> :
+    Value extends number ? ReturnType<typeof standardDatatypes.real> :
+      Value extends boolean ? ReturnType<typeof standardDatatypes.boolean> :
+        Value extends Date ? ReturnType<typeof standardDatatypes.timestamp> :
+          StandardNullDb
+
+type CastSourceDbType<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.DbTypeOf<Value>
+  : LiteralDbType<Value>
+
+type CastDialect<Value extends CastInput, Target extends CastTarget> =
+  CastSourceDbType<Value>["dialect"] | Target["dialect"]
+
+type CastNullability<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.NullabilityOf<Value>
+  : Value extends null ? "always" : "never"
+
+type CastKind<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.KindOf<Value>
+  : "scalar"
+
+type CastDependencies<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.DependenciesOf<Value>
+  : never
+
+type JsonbScalarCastTarget<Value extends CastInput, Target extends CastTarget> =
+  Value extends Expression.Any
+    ? Expression.DbTypeOf<Value> extends Expression.DbType.Json<"postgres", "jsonb">
+      ? [Expression.RuntimeOf<Value>] extends [number]
+        ? FamilyOfDbType<Target> extends "numeric" ? Target : never
+        : [Expression.RuntimeOf<Value>] extends [boolean]
+          ? FamilyOfDbType<Target> extends "boolean" ? Target : never
+          : never
+      : never
+    : never
+
+type CanCastJsonbScalar<Value extends CastInput, Target extends CastTarget> =
+  [JsonbScalarCastTarget<Value, Target>] extends [never]
+    ? false
+    : JsonbScalarCastTarget<Value, Target> extends Target
+      ? true
+      : false
+
+type CastTargetInput<Value extends CastInput, Target extends CastTarget> =
+  IsAny<Value> extends true
+    ? Target
+    : IsAny<Target> extends true
+      ? Target
+      : CanCastDbType<CastSourceDbType<Value>, Target, CastDialect<Value, Target>> extends true
+        ? Target
+        : CanCastJsonbScalar<Value, Target> extends true
+          ? Target
+        : CastTargetError<CastSourceDbType<Value>, Target, CastDialect<Value, Target>>
+
+type CastValueInput<Value extends CastInput, Target extends CastTarget> =
+  CastTargetInput<Value, Target> extends Target
+    ? Value
+    : CastTargetInput<Value, Target>
+
+type CastExpression<
+  Value extends CastInput,
+  Target extends CastTarget
+> = Expression.Scalar<
+  RuntimeOfDbType<Target>,
+  Target,
+  CastNullability<Value>,
+  CastDialect<Value, Target>,
+  CastKind<Value>,
+  CastDependencies<Value>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.CastNode<Value extends Expression.Any ? Value : Expression.Any, Target>
+}
+
+export const to: {
+  <Value extends CastInput, Target extends CastTarget>(
+    value: Value,
+    target: Target & CastTargetInput<Value, Target>
+  ): CastExpression<Value, Target>
+  // `NoInfer` keeps `Value` out of its own inference constraint: it is inferred
+  // from the argument, then validated against the already-fixed `Target`.
+  // Without it, the validation forms an inference fixpoint that explodes under
+  // higher-order inference (e.g. `.pipe`).
+  <Target extends CastTarget>(
+    target: Target
+  ): <Value extends CastInput>(value: Value & CastValueInput<NoInfer<Value>, Target>) => CastExpression<Value, Target>
+} = ((...args: [CastInput, CastTarget] | [CastTarget]) =>
+  args.length === 1
+    ? ((value: CastInput) => standardCast(value as never, args[0] as never))
+    : standardCast(args[0] as never, args[1] as never)) as unknown as typeof to

package/src/standard/check.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type CheckSpec = Extract<TableOptionSpec, { readonly kind: "check" }>
+
+export const make = BaseTable.check
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends CheckSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))

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>,
+  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.check(Schema.isMaxLength(length))
+
+const finiteNumber = Schema.Number.check(Schema.isFinite())
+
+export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbType.Any>(
+  schema: SchemaType,
+  dbType: Db
+) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
+    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.String.check(Schema.isUUID()), 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 ? undefined : `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.Uint8Array, standardDatatypes.blob())
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
+    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,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
+    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
+  })
+}
+
+export type StandardDatatypeModule = typeof standardDatatypes

package/src/standard/datatypes/spec.ts

@@ -0,0 +1,12 @@
+import {
+  portableDatatypeFamilies,
+  portableDatatypeKinds,
+  type PortableDatatypeFamily,
+  type PortableDatatypeKind
+} from "../../internal/datatypes/matrix.js"
+
+export const standardDatatypeFamilies = portableDatatypeFamilies
+export const standardDatatypeKinds = portableDatatypeKinds
+
+export type StandardDatatypeFamily = PortableDatatypeFamily
+export type StandardDatatypeKind = PortableDatatypeKind

package/src/standard/dialect.ts

@@ -0,0 +1,40 @@
+import { quoteDoubleQuotedIdentifier, type RenderState, type RenderValueContext, type SqlDialect } from "../internal/dialect.js"
+import { renderExpression, renderQueryAst } from "../internal/dialect-renderers/postgres.js"
+import { toDriverValue } from "../internal/runtime/driver-value-mapping.js"
+
+const quoteIdentifier = quoteDoubleQuotedIdentifier
+
+const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
+  const driverValue = toDriverValue(value, {
+    dialect: "standard",
+    valueMappings: state.valueMappings,
+    ...context
+  })
+  if (driverValue === null) {
+    return "null"
+  }
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false"
+  }
+  state.params.push(driverValue)
+  return "?"
+}
+
+export const standardDialect: SqlDialect<"standard"> = {
+  name: "standard",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName && schemaName !== "public"
+      ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
+      : quoteIdentifier(baseTableName)
+    return tableName === baseTableName
+      ? renderedBase
+      : `${renderedBase} as ${quoteIdentifier(tableName)}`
+  },
+  renderConcat(values) {
+    return `(${values.join(" || ")})`
+  },
+  renderQueryAst,
+  renderExpression
+}

package/src/standard/foreign-key.ts

@@ -0,0 +1,37 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type ForeignKeySpec = Extract<TableOptionSpec, { readonly kind: "foreignKey" }>
+
+export type ReferentialAction = BaseTable.ReferentialAction
+
+export const make = BaseTable.foreignKey
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))
+
+export const onDelete = (action: BaseTable.ReferentialAction) =>
+  <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly onDelete: BaseTable.ReferentialAction }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      onDelete: action
+    } as Spec & { readonly onDelete: BaseTable.ReferentialAction }))
+
+export const onUpdate = (action: BaseTable.ReferentialAction) =>
+  <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly onUpdate: BaseTable.ReferentialAction }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      onUpdate: action
+    } as Spec & { readonly onUpdate: BaseTable.ReferentialAction }))

package/src/standard/function/aggregate.ts

@@ -0,0 +1,2 @@
+/** Standard aggregate functions. */
+export { count, max, min } from "../query.js"

package/src/standard/function/core.ts

@@ -0,0 +1,2 @@
+/** Standard scalar core functions. */
+export { coalesce, call } from "../query.js"