effect-qb 0.12.3 → 0.14.0

package/src/postgres/table.ts

@@ -53,20 +53,26 @@ type SchemaNameOfTable<Table> = Table extends BaseTable.TableDefinition<any, any
     ? SchemaName
     : never
 
-export type TableSchemaNamespace<SchemaName extends string> = {
-  readonly schemaName: SchemaName
-  readonly table: <
-    Name extends string,
-    Fields extends DialectFieldMap,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...options: BaseTable.DeclaredTableOptions
-  ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+export type TableOption = BaseTable.TableOption
+export type DdlExpressionLike = BaseTable.DdlExpressionLike
+export type IndexKey = BaseTable.IndexKeySpec
+export type ReferentialAction = BaseTable.ReferentialAction
+
+type SchemaTable = {
+  readonly columns: Record<string, unknown>
 }
 
-export type TableOption = BaseTable.TableOption
+type TableExpressionFactory<Table extends SchemaTable> = (
+  columns: Table["columns"]
+) => DdlExpressionLike
+
+type TableScopedOptionBuilder<
+  Table extends SchemaTable,
+  Spec extends import("../internal/table-options.js").TableOptionSpec = import("../internal/table-options.js").TableOptionSpec
+> = {
+  (table: Table): Table
+  readonly option: Spec
+}
 
 export const TypeId = BaseTable.TypeId
 export const OptionsSymbol = BaseTable.OptionsSymbol
@@ -83,26 +89,6 @@ export const make = <
 ): TableDefinition<Name, Fields> =>
   BaseTable.make(name, fields, schemaName) as TableDefinition<Name, Fields>
 
-export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => ({
-  schemaName,
-  table: <
-    Name extends string,
-    Fields extends DialectFieldMap,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...declaredOptions: BaseTable.DeclaredTableOptions
-  ) =>
-    BaseTable.schema(schemaName).table(
-      name,
-      fields,
-      ...declaredOptions
-    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
-})
-
 export const alias = <
   Table extends AnyTable,
   AliasName extends string
@@ -136,21 +122,301 @@ export const Class = <Self = never, SchemaName extends string | undefined = "pub
     : TableClassStatic<typeof name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName>
 }
 
-export const primaryKey = BaseTable.primaryKey
-export const unique = BaseTable.unique
-export const index = BaseTable.index
-export const foreignKey = <
+export const option = BaseTable.option
+
+type RichPrimaryKeyInput<Columns extends string | readonly string[]> = {
+  readonly columns: Columns
+  readonly name?: string
+  readonly deferrable?: boolean
+  readonly initiallyDeferred?: boolean
+}
+
+type RichUniqueInput<Columns extends string | readonly string[]> = {
+  readonly columns: Columns
+  readonly name?: string
+  readonly nullsNotDistinct?: boolean
+  readonly deferrable?: boolean
+  readonly initiallyDeferred?: boolean
+}
+
+type RichIndexKeyInput =
+  | {
+      readonly column: string
+      readonly order?: "asc" | "desc"
+      readonly nulls?: "first" | "last"
+    }
+  | {
+      readonly expression: DdlExpressionLike
+      readonly order?: "asc" | "desc"
+      readonly nulls?: "first" | "last"
+    }
+
+type RichIndexInput<Columns extends string | readonly string[] = string | readonly string[]> = {
+  readonly columns?: Columns
+  readonly keys?: readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]
+  readonly name?: string
+  readonly unique?: boolean
+  readonly method?: string
+  readonly include?: readonly string[]
+  readonly predicate?: DdlExpressionLike
+}
+
+type RichForeignKeyInput<
   LocalColumns extends string | readonly string[],
   TargetTable extends AnyTable,
   TargetColumns extends string | readonly string[]
+> = {
+  readonly columns: LocalColumns
+  readonly target: () => TargetTable
+  readonly referencedColumns: TargetColumns
+  readonly name?: string
+  readonly onUpdate?: ReferentialAction
+  readonly onDelete?: ReferentialAction
+  readonly deferrable?: boolean
+  readonly initiallyDeferred?: boolean
+}
+
+type RichCheckInput<Name extends string = string> = {
+  readonly name: Name
+  readonly predicate: DdlExpressionLike
+  readonly noInherit?: boolean
+}
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const isTableExpressionFactory = (value: unknown): value is TableExpressionFactory<SchemaTable> =>
+  typeof value === "function"
+
+const makeTableScopedOption = <
+  Table extends SchemaTable,
+  Spec extends import("../internal/table-options.js").TableOptionSpec
+>(
+  placeholder: Spec,
+  resolve: (table: Table) => Spec
+): TableScopedOptionBuilder<Table, Spec> => {
+  const builder = ((table: Table) =>
+    BaseTable.option(resolve(table))(table as never)) as unknown as TableScopedOptionBuilder<Table, Spec>
+  ;(builder as { option: Spec }).option = placeholder
+  return builder
+}
+
+const normalizeColumns = (columns: string | readonly string[]): readonly [string, ...string[]] =>
+  (Array.isArray(columns) ? [...columns] : [columns]) as unknown as readonly [string, ...string[]]
+
+const normalizeIndexKeys = (
+  keys: readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]
+): readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]] =>
+  keys.map((key) => "expression" in key
+    ? {
+        kind: "expression",
+        expression: key.expression,
+        order: key.order,
+        nulls: key.nulls
+      }
+    : {
+        kind: "column",
+        column: key.column,
+        order: key.order,
+        nulls: key.nulls
+      }) as unknown as readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
+
+export const primaryKey: {
+  <const Columns extends string | readonly string[]>(
+    columns: Columns
+  ): BaseTable.TableOption<{
+    readonly kind: "primaryKey"
+    readonly columns: BaseTable.NormalizeColumns<Columns>
+  }>
+  <const Columns extends string | readonly string[]>(
+    spec: RichPrimaryKeyInput<Columns>
+  ): BaseTable.TableOption
+} = ((input: unknown) =>
+  isObject(input) && "columns" in input
+    ? BaseTable.option({
+        kind: "primaryKey",
+        columns: normalizeColumns((input as RichPrimaryKeyInput<string | readonly string[]>).columns),
+        name: (input as RichPrimaryKeyInput<string | readonly string[]>).name,
+        deferrable: (input as RichPrimaryKeyInput<string | readonly string[]>).deferrable,
+        initiallyDeferred: (input as RichPrimaryKeyInput<string | readonly string[]>).initiallyDeferred
+      })
+    : BaseTable.primaryKey(input as string | readonly string[])) as never
+
+export const unique: {
+  <const Columns extends string | readonly string[]>(
+    columns: Columns
+  ): BaseTable.TableOption<{
+    readonly kind: "unique"
+    readonly columns: BaseTable.NormalizeColumns<Columns>
+  }>
+  <const Columns extends string | readonly string[]>(
+    spec: RichUniqueInput<Columns>
+  ): BaseTable.TableOption
+} = ((input: unknown) =>
+  isObject(input) && "columns" in input && ("name" in input || "nullsNotDistinct" in input || "deferrable" in input || "initiallyDeferred" in input)
+    ? BaseTable.option({
+        kind: "unique",
+        columns: normalizeColumns((input as RichUniqueInput<string | readonly string[]>).columns),
+        name: (input as RichUniqueInput<string | readonly string[]>).name,
+        nullsNotDistinct: (input as RichUniqueInput<string | readonly string[]>).nullsNotDistinct,
+        deferrable: (input as RichUniqueInput<string | readonly string[]>).deferrable,
+        initiallyDeferred: (input as RichUniqueInput<string | readonly string[]>).initiallyDeferred
+      })
+    : BaseTable.unique(input as string | readonly string[])) as never
+
+export const index: {
+  <const Columns extends string | readonly string[]>(
+    columns: Columns
+  ): BaseTable.TableOption<{
+    readonly kind: "index"
+    readonly columns: BaseTable.NormalizeColumns<Columns>
+  }>
+  <Table extends SchemaTable, const Columns extends string | readonly string[]>(
+    spec: Omit<RichIndexInput<Columns>, "predicate"> & {
+      readonly predicate: TableExpressionFactory<Table>
+    }
+  ): TableScopedOptionBuilder<Table, {
+    readonly kind: "index"
+    readonly columns?: BaseTable.NormalizeColumns<Columns>
+    readonly keys?: readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
+    readonly name?: string
+    readonly unique?: boolean
+    readonly method?: string
+    readonly include?: readonly string[]
+    readonly predicate?: DdlExpressionLike
+  }>
+  <const Columns extends string | readonly string[]>(
+    spec: RichIndexInput<Columns>
+  ): BaseTable.TableOption
+} = ((input: unknown) =>
+  isObject(input) && ("keys" in input || "name" in input || "unique" in input || "method" in input || "include" in input || "predicate" in input)
+    ? (() => {
+        const spec = input as RichIndexInput<string | readonly string[]> & {
+          readonly predicate?: DdlExpressionLike | TableExpressionFactory<SchemaTable>
+        }
+        const predicate = spec.predicate
+        const placeholder = {
+          kind: "index" as const,
+          columns: spec.columns === undefined
+            ? undefined
+            : normalizeColumns(spec.columns),
+          keys: spec.keys === undefined
+            ? undefined
+            : normalizeIndexKeys(spec.keys),
+          name: spec.name,
+          unique: spec.unique,
+          method: spec.method,
+          include: spec.include,
+          predicate: predicate as unknown as DdlExpressionLike
+        }
+        return isTableExpressionFactory(predicate)
+          ? makeTableScopedOption(placeholder, (table) => ({
+              ...placeholder,
+              predicate: predicate(table.columns)
+            }))
+          : BaseTable.option({
+              ...placeholder,
+              predicate
+            })
+      })()
+    : BaseTable.index(input as string | readonly string[])) as never
+export const foreignKey = <
+  const LocalColumns extends string | readonly string[],
+  TargetTable extends AnyTable,
+  const TargetColumns extends string | readonly string[]
 >(
-  columns: LocalColumns,
-  target: () => TargetTable,
-  referencedColumns: TargetColumns
+  columnsOrSpec: LocalColumns | RichForeignKeyInput<LocalColumns, TargetTable, TargetColumns>,
+  target?: () => TargetTable,
+  referencedColumns?: TargetColumns
 ): BaseTable.TableOption =>
-  BaseTable.foreignKey(columns, target as () => BaseTable.AnyTable, referencedColumns)
+  isObject(columnsOrSpec) && "columns" in columnsOrSpec && "target" in columnsOrSpec
+    ? (() => {
+        const spec = columnsOrSpec as RichForeignKeyInput<LocalColumns, TargetTable, TargetColumns>
+        const targetTable = spec.target() as BaseTable.AnyTable
+        const targetState = targetTable[BaseTable.TypeId]
+        return BaseTable.option({
+        kind: "foreignKey",
+        columns: normalizeColumns(spec.columns),
+        name: spec.name,
+        references: () => ({
+          tableName: targetState.baseName,
+          schemaName: targetState.schemaName,
+          columns: normalizeColumns(spec.referencedColumns),
+          knownColumns: Object.keys(targetState.fields)
+        }),
+        onUpdate: spec.onUpdate,
+        onDelete: spec.onDelete,
+        deferrable: spec.deferrable,
+        initiallyDeferred: spec.initiallyDeferred
+      })
+      })()
+    : BaseTable.foreignKey(
+        columnsOrSpec as LocalColumns,
+        target as () => BaseTable.AnyTable,
+        referencedColumns as TargetColumns
+      )
 
-export const check = BaseTable.check
+export const check: {
+  <Name extends string>(name: Name, predicate: DdlExpressionLike): BaseTable.TableOption
+  <Name extends string, Table extends SchemaTable>(
+    name: Name,
+    predicate: TableExpressionFactory<Table>
+  ): TableScopedOptionBuilder<Table, {
+    readonly kind: "check"
+    readonly name: Name
+    readonly predicate: DdlExpressionLike
+  }>
+  <Name extends string, Table extends SchemaTable>(
+    spec: Omit<RichCheckInput<Name>, "predicate"> & {
+      readonly predicate: TableExpressionFactory<Table>
+    }
+  ): TableScopedOptionBuilder<Table, {
+    readonly kind: "check"
+    readonly name: Name
+    readonly predicate: DdlExpressionLike
+    readonly noInherit?: boolean
+  }>
+  <Name extends string>(spec: RichCheckInput<Name>): BaseTable.TableOption
+} = ((nameOrSpec: string | RichCheckInput, predicate?: DdlExpressionLike) =>
+  isObject(nameOrSpec)
+    ? (() => {
+        const spec = nameOrSpec as RichCheckInput & {
+          readonly predicate: DdlExpressionLike | TableExpressionFactory<SchemaTable>
+        }
+        const specPredicate = spec.predicate
+        const placeholder = {
+          kind: "check" as const,
+          name: spec.name,
+          predicate: specPredicate as unknown as DdlExpressionLike,
+          noInherit: spec.noInherit
+        }
+        return isTableExpressionFactory(specPredicate)
+          ? makeTableScopedOption(placeholder, (table) => ({
+              ...placeholder,
+              predicate: specPredicate(table.columns)
+            }))
+          : BaseTable.option({
+              ...placeholder,
+              predicate: specPredicate
+            })
+      })()
+    : (() => {
+        const predicateOrFactory = predicate as DdlExpressionLike | TableExpressionFactory<SchemaTable>
+        const placeholder = {
+          kind: "check" as const,
+          name: nameOrSpec,
+          predicate: predicateOrFactory as unknown as DdlExpressionLike
+        }
+        return isTableExpressionFactory(predicateOrFactory)
+          ? makeTableScopedOption(placeholder, (table) => ({
+              ...placeholder,
+              predicate: predicateOrFactory(table.columns)
+            }))
+          : BaseTable.option({
+              ...placeholder,
+              predicate: predicateOrFactory
+            })
+      })()) as never
 
 export type SelectOf<Table extends { readonly schemas: { readonly select: Schema.Schema<any> } }> = BaseTable.SelectOf<Table>
 export type InsertOf<Table extends { readonly schemas: { readonly insert: Schema.Schema<any> } }> = BaseTable.InsertOf<Table>

package/src/postgres/type.ts

@@ -0,0 +1,4 @@
+import { postgresQuery } from "./private/query.js"
+
+/** Postgres database-type constructors for casts and typed column references. */
+export const type = postgresQuery.type

package/src/postgres.ts

@@ -6,12 +6,28 @@ export * as Datatypes from "./postgres/datatypes/index.js"
 export * as Errors from "./postgres/errors/index.js"
 /** Shared scalar SQL expression interfaces and DB-type descriptors. */
 export * as Expression from "./internal/expression.js"
+/** Postgres cast helpers. */
+export { cast as Cast } from "./postgres/cast.js"
+/** Postgres-specialized SQL function expressions. */
+export * as Function from "./postgres/function/index.js"
 /** Postgres-specialized typed query execution contracts. */
 export * as Executor from "./postgres/executor.js"
 /** Shared logical query-plan interfaces. */
 export * as Plan from "./internal/plan.js"
 /** Postgres-specialized query-construction DSL. */
 export * as Query from "./postgres/query.js"
+/** Postgres database-type constructors for casts and typed references. */
+export { type as Type } from "./postgres/type.js"
+/** Postgres normalized table/enum metadata helpers. */
+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 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. */
 export * as Table from "./postgres/table.js"
 /** Postgres-specialized built-in renderer entrypoint. */