effect-qb 0.19.0 → 0.20.0

package/src/postgres/jsonb.ts

@@ -7,7 +7,6 @@ export const index = jsonb.index
 export const wildcard = jsonb.wildcard
 export const slice = jsonb.slice
 export const descend = jsonb.descend
-export const path = jsonb.path
 export const get = jsonb.get
 export const access = jsonb.access
 export const traverse = jsonb.traverse

package/src/postgres/primary-key.ts

@@ -0,0 +1,24 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type PrimaryKeySpec = Extract<TableOptionSpec, { readonly kind: "primaryKey" }>
+
+export const deferrable = <Spec extends PrimaryKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly deferrable: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true
+  } as Spec & { readonly deferrable: true }))
+
+export const initiallyDeferred = <Spec extends PrimaryKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & {
+  readonly deferrable: true
+  readonly initiallyDeferred: true
+}, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true,
+    initiallyDeferred: true
+  } as Spec & { readonly deferrable: true; readonly initiallyDeferred: true }))

package/src/postgres/renderer.ts

@@ -20,6 +20,9 @@ export type ValueMappings = Expression.DriverValueMappingsFor<PostgresDatatypeKi
 
 export interface MakeOptions {
   readonly valueMappings?: ValueMappings
+}
+
+interface RendererState extends MakeOptions {
   readonly casing?: Casing.Options
 }
 
@@ -33,19 +36,23 @@ const RendererProto = {
 }
 
 /** Creates the built-in Postgres renderer. */
-export const make = (options: MakeOptions = {}): Renderer => {
-  const renderer = CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(plan, options))
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(plan, state))
   return Object.assign(Object.create(RendererProto), renderer, {
     [Casing.TypeId]: {
-      casing: options.casing
+      casing: state.casing
     },
     withCasing: (override: Casing.Options) =>
-      make({
-        ...options,
-        casing: Casing.merge(options.casing, override)
+      makeWithState({
+        ...state,
+        casing: Casing.merge(state.casing, override)
       })
   }) as Renderer
 }
 
+/** Creates the built-in Postgres renderer. */
+export const make = (options: MakeOptions = {}): Renderer =>
+  makeWithState({ valueMappings: options.valueMappings })
+
 /** Shared built-in Postgres renderer instance. */
 export const postgres = make()

package/src/postgres/schema-management.ts

@@ -138,13 +138,8 @@ const EnumProto = {
     }
   },
   column(this: EnumDefinition) {
-    const [first, ...rest] = this.values
-    const values: readonly [Schema.Schema.Any, ...Schema.Schema.Any[]] = [
-      Schema.Literal(first),
-      ...rest.map((value) => Schema.Literal(value))
-    ]
     return makeColumnDefinition(
-      values.length === 1 ? values[0]! : Schema.Union(...values),
+      Schema.Literals(this.values),
       {
         dbType: this.type(),
         nullable: false,

package/src/postgres/schema.ts

@@ -27,14 +27,21 @@ type ApplySchemaTableOptions<
 > = BaseTable.ApplyDeclaredOptions<
   BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
   Options
-> extends BaseTable.TableDefinition<any, any, infer AppliedPrimaryKeyColumns extends keyof Fields & string, "schema", any>
-  ? BaseTable.TableDefinition<Name, Fields, AppliedPrimaryKeyColumns, "schema", SchemaName>
+> extends BaseTable.TableDefinition<
+  any,
+  any,
+  infer AppliedPrimaryKeyColumns extends keyof Fields & string,
+  "schema",
+  any,
+  infer AppliedConflictArbiters extends BaseTable.ConflictArbiter
+>
+  ? BaseTable.TableDefinition<Name, Fields, AppliedPrimaryKeyColumns, "schema", SchemaName, AppliedConflictArbiters>
   : BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
 
 type ValidatePostgresSchemaTable<
-  Table extends BaseTable.TableDefinition<any, any, any, any, any>
-> = Table extends BaseTable.TableDefinition<any, infer Fields extends TableFieldMap, any, any, any>
-  ? BaseTable.TableDefinition<any, Fields & ValidatePostgresSchemaFields<Fields>, any, any, any>
+  Table extends BaseTable.TableDefinition<any, any, any, any, any, any>
+> = Table extends BaseTable.TableDefinition<any, infer Fields extends TableFieldMap, any, any, any, any>
+  ? BaseTable.TableDefinition<any, Fields & ValidatePostgresSchemaFields<Fields>, any, any, any, any>
   : never
 
 export type SchemaNamespace<SchemaName extends string> = Pipeable & {
@@ -62,13 +69,14 @@ export type SchemaNamespace<SchemaName extends string> = Pipeable & {
     name: BaseTable.NonEmptyStringInput<Name>
   ) => SequenceDefinition<Name, SchemaName>
   readonly withSchema: <
-    Table extends BaseTable.TableDefinition<any, any, any, any, any>
+    Table extends BaseTable.TableDefinition<any, any, any, any, any, any>
   >(table: Table & ValidatePostgresSchemaTable<Table>) => BaseTable.TableDefinition<
     Table[typeof BaseTable.TypeId]["name"],
     Table[typeof BaseTable.TypeId]["fields"],
     Table[typeof BaseTable.TypeId]["primaryKey"][number],
     Table[typeof BaseTable.TypeId]["kind"],
-    SchemaName
+    SchemaName,
+    Table[typeof BaseTable.TypeId]["conflictArbiters"][number]
   >
   readonly [Casing.TypeId]: Casing.State
   readonly withCasing: (options: Casing.Options) => SchemaNamespace<SchemaName>
@@ -107,7 +115,7 @@ export const make = <SchemaName extends string>(
     name: BaseTable.NonEmptyStringInput<Name>
   ) => sequence(Casing.applyCategory(options.casing, "sequences", name), physicalSchemaName) as SequenceDefinition<Name, SchemaName>
   namespace.withSchema = <
-    Table extends BaseTable.TableDefinition<any, any, any, any, any>
+    Table extends BaseTable.TableDefinition<any, any, any, any, any, any>
   >(table: Table & ValidatePostgresSchemaTable<Table>) => BaseTable.withSchema(table, schemaName, options.casing)
   namespace[Casing.TypeId] = {
     casing: options.casing

package/src/postgres/table.ts

@@ -15,28 +15,20 @@ type IndexSpec = Extract<TableOptionSpec, { readonly kind: "index" }>
 type ForeignKeySpec = Extract<TableOptionSpec, { readonly kind: "foreignKey" }>
 type CheckSpec = Extract<TableOptionSpec, { readonly kind: "check" }>
 
-type NonEmptyStringArrayInput<Values extends readonly string[]> =
-  [Extract<Values[number], "">] extends [never] ? unknown : never
-
-type IndexKeyInput =
+type IndexKeyOptions = {
+  readonly order?: "asc" | "desc"
+  readonly nulls?: "first" | "last"
+  readonly operatorClass?: string
+  readonly collation?: string
+}
+
+type IndexKeyInput<Table extends BaseTable.SchemaTableDefinition = BaseTable.SchemaTableDefinition> =
   | {
-      readonly column: string
-      readonly order?: "asc" | "desc"
-      readonly nulls?: "first" | "last"
-      readonly operatorClass?: string
-      readonly collation?: string
-    }
+      readonly column: BaseTable.TableColumn<Table>
+    } & IndexKeyOptions
   | {
       readonly expression: BaseTable.DdlExpressionLike
-      readonly order?: "asc" | "desc"
-      readonly nulls?: "first" | "last"
-      readonly operatorClass?: string
-      readonly collation?: string
-    }
-
-type EmptyIndexKeyColumn<Key> = Key extends { readonly column: infer Column extends string }
-  ? BaseTable.NonEmptyStringInput<Column> extends never ? Key : never
-  : never
+    } & IndexKeyOptions
 
 type EmptyIndexKeyOperatorClass<Key> = Key extends { readonly operatorClass: infer OperatorClass extends string }
   ? BaseTable.NonEmptyStringInput<OperatorClass> extends never ? Key : never
@@ -47,7 +39,6 @@ type EmptyIndexKeyCollation<Key> = Key extends { readonly collation: infer Colla
   : never
 
 type InvalidIndexKeyMetadata<Key> =
-  | EmptyIndexKeyColumn<Key>
   | EmptyIndexKeyOperatorClass<Key>
   | EmptyIndexKeyCollation<Key>
 
@@ -63,10 +54,10 @@ type NormalizedIndexKey<Key> = Key extends { readonly expression: infer Expressi
       readonly operatorClass: Key extends { readonly operatorClass: infer OperatorClass extends string } ? OperatorClass : undefined
       readonly collation: Key extends { readonly collation: infer Collation extends string } ? Collation : undefined
     }
-  : Key extends { readonly column: infer Column extends string }
+  : Key extends { readonly column: infer Column extends BaseTable.AnyColumnSelection }
     ? {
         readonly kind: "column"
-        readonly column: Column
+        readonly column: BaseTable.SelectedColumns<Column>[number]
         readonly order: Key extends { readonly order: infer Order extends "asc" | "desc" } ? Order : undefined
         readonly nulls: Key extends { readonly nulls: infer Nulls extends "first" | "last" } ? Nulls : undefined
         readonly operatorClass: Key extends { readonly operatorClass: infer OperatorClass extends string } ? OperatorClass : undefined
@@ -74,15 +65,6 @@ type NormalizedIndexKey<Key> = Key extends { readonly expression: infer Expressi
       }
     : never
 
-type NormalizedIndexKeys<Keys extends readonly [IndexKeyInput, ...IndexKeyInput[]]> = {
-  readonly [Index in keyof Keys]: NormalizedIndexKey<Keys[Index]>
-} & readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
-
-const mapOption = <Next extends TableOptionSpec>(
-  next: Next
-): BaseTable.TableOption<Next> =>
-  BaseTable.option(next)
-
 const normalizeIndexKey = (key: IndexKeyInput): BaseTable.IndexKeySpec =>
   "expression" in key
     ? {
@@ -95,7 +77,7 @@ const normalizeIndexKey = (key: IndexKeyInput): BaseTable.IndexKeySpec =>
       }
     : {
         kind: "column",
-        column: key.column,
+        column: BaseTable.selectedColumnList(key.column)[0]!,
         order: key.order,
         nulls: key.nulls,
         operatorClass: key.operatorClass,
@@ -106,131 +88,147 @@ const normalizeIndexKey = (key: IndexKeyInput): BaseTable.IndexKeySpec =>
 export const named = <const Name extends string>(
   name: BaseTable.NonEmptyStringInput<Name>
 ) =>
-  <Spec extends NamedSpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & { readonly name: Name }> =>
-    mapOption({
-      ...option.option,
+  <Spec extends NamedSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
       name
-    } as Spec & { readonly name: Name })
+    } as Spec & { readonly name: Name }))
 
 /** Marks a standard primary key, unique, or foreign-key option as deferrable. */
 export const deferrable = <
-  Spec extends PrimaryKeySpec | UniqueSpec | ForeignKeySpec
->(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & { readonly deferrable: true }> =>
-  mapOption({
-    ...option.option,
+  Spec extends PrimaryKeySpec | UniqueSpec | ForeignKeySpec,
+  TableContext extends BaseTable.SchemaTableDefinition
+>(option: BaseTable.TableOption<Spec, TableContext>): BaseTable.TableOption<Spec & { readonly deferrable: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
     deferrable: true
-  } as Spec & { readonly deferrable: true })
+  } as Spec & { readonly deferrable: true }))
 
 /** Marks a deferrable standard primary key, unique, or foreign-key option as initially deferred. */
 export const initiallyDeferred = <
-  Spec extends PrimaryKeySpec | UniqueSpec | ForeignKeySpec
->(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & {
+  Spec extends PrimaryKeySpec | UniqueSpec | ForeignKeySpec,
+  TableContext extends BaseTable.SchemaTableDefinition
+>(option: BaseTable.TableOption<Spec, TableContext>): BaseTable.TableOption<Spec & {
   readonly deferrable: true
   readonly initiallyDeferred: true
-}> =>
-  mapOption({
-    ...option.option,
+}, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
     deferrable: true,
     initiallyDeferred: true
-  } as Spec & { readonly deferrable: true; readonly initiallyDeferred: true })
+  } as Spec & { readonly deferrable: true; readonly initiallyDeferred: true }))
 
 /** Adds Postgres NULLS NOT DISTINCT to a standard unique option. */
-export const nullsNotDistinct = <Spec extends UniqueSpec>(
-  option: BaseTable.TableOption<Spec>
-): BaseTable.TableOption<Spec & { readonly nullsNotDistinct: true }> =>
-  mapOption({
-    ...option.option,
+export const nullsNotDistinct = <Spec extends UniqueSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly nullsNotDistinct: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
     nullsNotDistinct: true
-  } as Spec & { readonly nullsNotDistinct: true })
+  } as Spec & { readonly nullsNotDistinct: true }))
 
 /** Marks a standard index option as a Postgres unique index. */
-export const uniqueIndex = <Spec extends IndexSpec>(
-  option: BaseTable.TableOption<Spec>
-): BaseTable.TableOption<Spec & { readonly unique: true }> =>
-  mapOption({
-    ...option.option,
+export const uniqueIndex = <Spec extends IndexSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly unique: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
     unique: true
-  } as Spec & { readonly unique: true })
+  } as Spec & { readonly unique: true }))
 
 /** Adds a Postgres index method to a standard index option. */
 export const using = <const Method extends string>(
   method: BaseTable.NonEmptyStringInput<Method>
 ) =>
-  <Spec extends IndexSpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & { readonly method: Method }> =>
-    mapOption({
-      ...option.option,
+  <Spec extends IndexSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly method: Method }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
       method
-    } as Spec & { readonly method: Method })
+    } as Spec & { readonly method: Method }))
 
 /** Adds Postgres INCLUDE columns to a standard index option. */
-export const include = <const Include extends readonly string[]>(
-  include: Include & NonEmptyStringArrayInput<Include>
+export const include = <
+  Selection extends BaseTable.AnyColumnSelection
+>(
+  columns: (table: any) => Selection
 ) =>
-  <Spec extends IndexSpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & { readonly include: Include }> =>
-    mapOption({
+  <Spec extends IndexSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly include: BaseTable.SelectedColumns<Selection> }, TableContext> =>
+    BaseTable.optionFromTable({
       ...option.option,
-      include
-    } as Spec & { readonly include: Include })
+      include: [] as unknown as BaseTable.SelectedColumns<Selection>
+    } as Spec & { readonly include: BaseTable.SelectedColumns<Selection> }, (table) => ({
+      ...BaseTable.resolveOption(option, table as TableContext),
+      include: BaseTable.selectedColumnList(columns(table))
+    } as Spec & { readonly include: BaseTable.SelectedColumns<Selection> }))
 
 /** Adds a Postgres partial-index predicate to a standard index option. */
 export const where = <Predicate extends BaseTable.DdlExpressionLike>(
   predicate: Predicate
 ) =>
-  <Spec extends IndexSpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & { readonly predicate: Predicate }> =>
-    mapOption({
-      ...option.option,
+  <Spec extends IndexSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly predicate: Predicate }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
       predicate
-    } as Spec & { readonly predicate: Predicate })
+    } as Spec & { readonly predicate: Predicate }))
 
 /** Replaces standard index columns with a single Postgres index key. */
-export const key = <const Key extends IndexKeyInput>(
-  key: Key & NonEmptyIndexKeyInput<Key>
+export const key = <
+  Column extends BaseTable.TableColumn<BaseTable.SchemaTableDefinition>,
+  const Options extends IndexKeyOptions = {}
+>(
+  column: (table: any) => Column,
+  options?: Options & NonEmptyIndexKeyInput<Options>
 ) =>
-  <Spec extends IndexSpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & {
-    readonly keys: readonly [NormalizedIndexKey<Key>]
-  }> =>
-    mapOption({
+  <Spec extends IndexSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & {
+    readonly keys: readonly [NormalizedIndexKey<{ readonly column: Column } & Options>]
+  }, TableContext> =>
+    BaseTable.optionFromTable({
       ...option.option,
       columns: undefined,
-      keys: [normalizeIndexKey(key)]
-    } as unknown as Spec & { readonly keys: readonly [NormalizedIndexKey<Key>] })
+      keys: [] as unknown as readonly [NormalizedIndexKey<{ readonly column: Column } & Options>]
+    } as unknown as Spec & { readonly keys: readonly [NormalizedIndexKey<{ readonly column: Column } & Options>] }, (table) => ({
+      ...BaseTable.resolveOption(option, table as TableContext),
+      columns: undefined,
+      keys: [normalizeIndexKey({ column: column(table), ...options })]
+    } as unknown as Spec & { readonly keys: readonly [NormalizedIndexKey<{ readonly column: Column } & Options>] }))
 
 /** Replaces standard index columns with Postgres index keys. */
-export const keys = <const Keys extends readonly [IndexKeyInput, ...IndexKeyInput[]]>(
-  keys: Keys & {
-    readonly [Index in keyof Keys]: Keys[Index] & NonEmptyIndexKeyInput<Keys[Index]>
-  }
+export const keys = (
+  keys: (table: any) => readonly [IndexKeyInput, ...IndexKeyInput[]]
 ) =>
-  <Spec extends IndexSpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & {
-    readonly keys: NormalizedIndexKeys<Keys>
-  }> =>
-    mapOption({
+  <Spec extends IndexSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & {
+    readonly keys: readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
+  }, TableContext> =>
+    BaseTable.optionFromTable({
       ...option.option,
       columns: undefined,
-      keys: [normalizeIndexKey(keys[0]), ...keys.slice(1).map(normalizeIndexKey)]
-    } as Spec & { readonly keys: NormalizedIndexKeys<Keys> })
-
-/** Adds an ON DELETE action to a standard foreign-key option. */
-export const onDelete = (action: BaseTable.ReferentialAction) =>
-  <Spec extends ForeignKeySpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & { readonly onDelete: BaseTable.ReferentialAction }> =>
-    mapOption({
-      ...option.option,
-      onDelete: action
-    } as Spec & { readonly onDelete: BaseTable.ReferentialAction })
-
-/** Adds an ON UPDATE action to a standard foreign-key option. */
-export const onUpdate = (action: BaseTable.ReferentialAction) =>
-  <Spec extends ForeignKeySpec>(option: BaseTable.TableOption<Spec>): BaseTable.TableOption<Spec & { readonly onUpdate: BaseTable.ReferentialAction }> =>
-    mapOption({
-      ...option.option,
-      onUpdate: action
-    } as Spec & { readonly onUpdate: BaseTable.ReferentialAction })
+      keys: [] as unknown as readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
+    } as Spec & { readonly keys: readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]] }, (table) => {
+      const resolvedKeys = keys(table)
+      return {
+        ...BaseTable.resolveOption(option, table as TableContext),
+        columns: undefined,
+        keys: [normalizeIndexKey(resolvedKeys[0]), ...resolvedKeys.slice(1).map(normalizeIndexKey)]
+      } as Spec & { readonly keys: readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]] }
+    })
 
 /** Adds Postgres NO INHERIT to a standard check option. */
-export const noInherit = <Spec extends CheckSpec>(
-  option: BaseTable.TableOption<Spec>
-): BaseTable.TableOption<Spec & { readonly noInherit: true }> =>
-  mapOption({
-    ...option.option,
+export const noInherit = <Spec extends CheckSpec, TableContext extends BaseTable.SchemaTableDefinition>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly noInherit: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
     noInherit: true
-  } as Spec & { readonly noInherit: true })
+  } as Spec & { readonly noInherit: true }))

package/src/postgres/type.ts

@@ -1,9 +1,15 @@
 import type * as Expression from "../internal/scalar.js"
 import type { NonEmptyStringInput } from "../internal/table-options.js"
+import {
+  pickDatatypeConstructors,
+  postgresSpecificDatatypeKeys,
+  type PostgresSpecificDatatypeKey
+} from "../internal/datatypes/matrix.js"
 import { postgresDatatypes } from "./datatypes/index.js"
-import { type as postgresType } from "./internal/dsl.js"
 
-type PostgresTypeNamespace = typeof postgresDatatypes & {
+type PostgresSpecificDatatypes = Pick<typeof postgresDatatypes, PostgresSpecificDatatypeKey>
+
+type PostgresTypeNamespace = PostgresSpecificDatatypes & {
   readonly array: <Element extends Expression.DbType.Any>(
     element: Element
   ) => Expression.DbType.Array<"postgres", Element, `${Element["kind"]}[]`>
@@ -24,7 +30,6 @@ type PostgresTypeNamespace = typeof postgresDatatypes & {
     base: Base
   ) => Expression.DbType.Domain<"postgres", Base, Kind>
   readonly enum: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Enum<"postgres", Kind>
-  readonly set: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Set<"postgres", Kind>
   readonly custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"postgres", Kind>
   readonly driverValueMapping: <Db extends Expression.DbType.Any>(
     dbType: Db,
@@ -32,5 +37,82 @@ type PostgresTypeNamespace = typeof postgresDatatypes & {
   ) => Db
 }
 
+const array = <Element extends Expression.DbType.Any>(
+  element: Element
+): Expression.DbType.Array<"postgres", Element, `${Element["kind"]}[]`> => ({
+  dialect: "postgres",
+  kind: `${element.kind}[]`,
+  element
+})
+
+const range = <Kind extends string, Subtype extends Expression.DbType.Any>(
+  kind: NonEmptyStringInput<Kind>,
+  subtype: Subtype
+): Expression.DbType.Range<"postgres", Subtype, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  subtype
+})
+
+const multirange = <Kind extends string, Subtype extends Expression.DbType.Any>(
+  kind: NonEmptyStringInput<Kind>,
+  subtype: Subtype
+): Expression.DbType.Multirange<"postgres", Subtype, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  subtype
+})
+
+const record = <Kind extends string, Fields extends Record<string, Expression.DbType.Any>>(
+  kind: NonEmptyStringInput<Kind>,
+  fields: Fields
+): Expression.DbType.Composite<"postgres", Fields, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  fields
+})
+
+const domain = <Kind extends string, Base extends Expression.DbType.Any>(
+  kind: NonEmptyStringInput<Kind>,
+  base: Base
+): Expression.DbType.Domain<"postgres", Base, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  base
+})
+
+const enum_ = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Enum<"postgres", Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  variant: "enum"
+})
+
+const custom = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Base<"postgres", Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind
+})
+
+const driverValueMapping = <Db extends Expression.DbType.Any>(
+  dbType: Db,
+  mapping: Expression.DriverValueMapping
+): Db => ({
+  ...dbType,
+  driverValueMapping: mapping
+})
+
 /** Postgres database-type constructors for casts and typed column references. */
-export const type: PostgresTypeNamespace = postgresType
+export const type: PostgresTypeNamespace = {
+  ...pickDatatypeConstructors(postgresDatatypes, postgresSpecificDatatypeKeys),
+  array,
+  range,
+  multirange,
+  record,
+  domain,
+  enum: enum_,
+  custom,
+  driverValueMapping
+}

package/src/postgres/unique.ts

@@ -0,0 +1,32 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type UniqueSpec = Extract<TableOptionSpec, { readonly kind: "unique" }>
+
+export const deferrable = <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly deferrable: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true
+  } as Spec & { readonly deferrable: true }))
+
+export const initiallyDeferred = <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & {
+  readonly deferrable: true
+  readonly initiallyDeferred: true
+}, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true,
+    initiallyDeferred: true
+  } as Spec & { readonly deferrable: true; readonly initiallyDeferred: true }))
+
+export const nullsNotDistinct = <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly nullsNotDistinct: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    nullsNotDistinct: true
+  } as Spec & { readonly nullsNotDistinct: true }))

package/src/postgres.ts

@@ -4,12 +4,10 @@ export * as Column from "./postgres/column-extension.js"
 export * as Datatypes from "./postgres/datatypes/index.js"
 /** Postgres SQLSTATE catalog and error normalization helpers. */
 export * as Errors from "./postgres/errors/index.js"
-/** Postgres cast helpers. */
-export { cast as Cast } from "./postgres/cast.js"
 /** 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-specific JSON expression helpers. Portable JSON helpers are exported from the root package. */
+export * as Json from "./postgres/json-extension.js"
 /** Postgres jsonb-only expression helpers. */
 export * as Jsonb from "./postgres/jsonb.js"
 /** Postgres-specialized typed query execution contracts. */
@@ -28,7 +26,15 @@ 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-specific table-option extensions. Portable tables are exported from `effect-qb`. */
-export * as Table from "./postgres/table.js"
+/** Postgres-specific primary-key option modifiers. */
+export * as PrimaryKey from "./postgres/primary-key.js"
+/** Postgres-specific unique-constraint option modifiers. */
+export * as Unique from "./postgres/unique.js"
+/** Postgres-specific index option modifiers. */
+export * as Index from "./postgres/index.js"
+/** Postgres-specific foreign-key option modifiers. */
+export * as ForeignKey from "./postgres/foreign-key.js"
+/** Postgres-specific check-constraint option modifiers. */
+export * as Check from "./postgres/check.js"
 /** Postgres-specialized built-in renderer entrypoint. */
 export * as Renderer from "./postgres/renderer.js"