effect-qb 0.17.0 → 0.20.0

package/src/postgres/jsonb.ts

@@ -0,0 +1,37 @@
+import { jsonb } from "./json.js"
+
+/** Postgres jsonb-only helpers for containment, mutation, wildcard paths, and SQL/JSON path predicates. */
+export { jsonb }
+export const key = jsonb.key
+export const index = jsonb.index
+export const wildcard = jsonb.wildcard
+export const slice = jsonb.slice
+export const descend = jsonb.descend
+export const get = jsonb.get
+export const access = jsonb.access
+export const traverse = jsonb.traverse
+export const text = jsonb.text
+export const accessText = jsonb.accessText
+export const traverseText = jsonb.traverseText
+export const contains = jsonb.contains
+export const containedBy = jsonb.containedBy
+export const hasKey = jsonb.hasKey
+export const keyExists = jsonb.keyExists
+export const hasAnyKeys = jsonb.hasAnyKeys
+export const hasAllKeys = jsonb.hasAllKeys
+export const delete_ = jsonb.delete
+export { delete_ as delete }
+export const remove = jsonb.remove
+export const set = jsonb.set
+export const insert = jsonb.insert
+export const concat = jsonb.concat
+export const merge = jsonb.merge
+export const buildObject = jsonb.buildObject
+export const buildArray = jsonb.buildArray
+export const toJsonb = jsonb.toJsonb
+export const typeOf = jsonb.typeOf
+export const length = jsonb.length
+export const keys = jsonb.keys
+export const stripNulls = jsonb.stripNulls
+export const pathExists = jsonb.pathExists
+export const pathMatch = jsonb.pathMatch

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/query-extension.ts

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

package/src/postgres/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 { PostgresDatatypeFamily, PostgresDatatypeKind } from "./datatypes/spec.js"
 import { renderPostgresPlan } from "./internal/renderer.js"
 
 /** Postgres-specialized rendered query shape. */
@@ -7,18 +11,48 @@ export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "postgres">
 /** Extracts the row type carried by a Postgres rendered query. */
 export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
 /** Postgres-specialized renderer contract. */
-export type Renderer = CoreRenderer.Renderer<"postgres">
+export type Renderer = CoreRenderer.Renderer<"postgres"> & Pipeable & {
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => Renderer
+}
+
+export type ValueMappings = Expression.DriverValueMappingsFor<PostgresDatatypeKind, PostgresDatatypeFamily>
 
 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 Postgres renderer. */
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(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 Postgres renderer. */
 export const make = (options: MakeOptions = {}): Renderer =>
-  CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, options))
+  makeWithState({ valueMappings: options.valueMappings })
 
 /** Shared built-in Postgres renderer instance. */
 export const postgres = make()

package/src/postgres/schema-management.ts

@@ -3,6 +3,7 @@ import { pipeArguments, type Pipeable } from "effect/Pipeable"
 
 import type * as Expression from "../internal/scalar.js"
 import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
 
 export const EnumTypeId: unique symbol = Symbol.for("effect-qb/SchemaManagement/Enum")
 export const SequenceTypeId: unique symbol = Symbol.for("effect-qb/SchemaManagement/Sequence")
@@ -121,7 +122,7 @@ const renderQualifiedTypeName = (
     : `${renderIdentifier(schemaName)}.${renderIdentifier(name)}`
 
 const EnumProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   },
   qualifiedName(this: EnumDefinition) {
@@ -137,9 +138,8 @@ const EnumProto = {
     }
   },
   column(this: EnumDefinition) {
-    const values = this.values.map((value) => Schema.Literal(value)) as unknown as readonly [Schema.Schema.Any, ...Schema.Schema.Any[]]
     return makeColumnDefinition(
-      values.length === 1 ? values[0]! : Schema.Union(...values),
+      Schema.Literals(this.values),
       {
         dbType: this.type(),
         nullable: false,
@@ -161,7 +161,7 @@ const EnumProto = {
 }
 
 const SequenceProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   },
   qualifiedName(this: SequenceDefinition) {
@@ -212,7 +212,7 @@ export function enumType<
   Name extends string,
   const Values extends readonly [string, ...string[]]
 >(
-  name: Name,
+  name: NonEmptyStringInput<Name>,
   values: Values
 ): EnumDefinition<Name, Values, undefined>
 export function enumType<
@@ -220,9 +220,9 @@ export function enumType<
   const Values extends readonly [string, ...string[]],
   SchemaName extends string
 >(
-  name: Name,
+  name: NonEmptyStringInput<Name>,
   values: Values,
-  schemaName: SchemaName
+  schemaName: NonEmptyStringInput<SchemaName>
 ): EnumDefinition<Name, Values, SchemaName>
 export function enumType(
   name: string,
@@ -243,11 +243,11 @@ export function enumType(
 }
 
 export function sequence<Name extends string>(
-  name: Name
+  name: NonEmptyStringInput<Name>
 ): SequenceDefinition<Name, undefined>
 export function sequence<Name extends string, SchemaName extends string>(
-  name: Name,
-  schemaName: SchemaName
+  name: NonEmptyStringInput<Name>,
+  schemaName: NonEmptyStringInput<SchemaName>
 ): SequenceDefinition<Name, SchemaName>
 export function sequence(
   name: string,
@@ -265,21 +265,21 @@ export function sequence(
 }
 
 export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
+  schemaName: NonEmptyStringInput<SchemaName>
 ) => ({
   schemaName,
   enumType: <
     Name extends string,
     const Values extends readonly [string, ...string[]]
   >(
-    name: Name,
+    name: NonEmptyStringInput<Name>,
     values: Values
   ): EnumDefinition<Name, Values, SchemaName> =>
     enumType(name, values, schemaName) as EnumDefinition<Name, Values, SchemaName>,
   sequence: <
     Name extends string
   >(
-    name: Name
+    name: NonEmptyStringInput<Name>
   ): SequenceDefinition<Name, SchemaName> =>
     sequence(name, schemaName) as SequenceDefinition<Name, SchemaName>
 })

package/src/postgres/schema.ts

@@ -1,35 +1,126 @@
-import { schema as makeTableSchemaNamespace, type TableSchemaNamespace } from "./table.js"
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
+import { ColumnTypeId } from "../internal/column-state.js"
+import type { AnyColumnDefinition } from "../internal/column-state.js"
+import * as Casing from "../internal/casing.js"
+import * as BaseTable from "../internal/table.js"
+import type { TableFieldMap } from "../internal/schema-derivation.js"
+import { make as makeTable } from "../standard/table.js"
 import { enumType, sequence, type EnumDefinition, type SequenceDefinition } from "./schema-management.js"
 
-export type SchemaNamespace<SchemaName extends string> = TableSchemaNamespace<SchemaName> & {
+type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
+  [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never
+}[keyof Fields], string>
+
+type FieldDialect<Column extends AnyColumnDefinition> = Column[typeof ColumnTypeId]["dbType"]["dialect"]
+
+type ValidatePostgresSchemaFields<Fields extends TableFieldMap> = {
+  [K in keyof Fields]: Exclude<FieldDialect<Fields[K]>, "standard" | "postgres"> extends never ? Fields[K] : never
+}
+
+type ApplySchemaTableOptions<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string,
+  SchemaName extends string,
+  Options extends BaseTable.DeclaredTableOptions
+> = BaseTable.ApplyDeclaredOptions<
+  BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
+  Options
+> 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, 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 & {
+  readonly schemaName: SchemaName
+  readonly table: <
+    Name extends string,
+    Fields extends TableFieldMap,
+    const Options extends BaseTable.DeclaredTableOptions,
+    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
+  >(
+    name: BaseTable.NonEmptyStringInput<Name>,
+    fields: Fields & BaseTable.NonEmptyFieldMap<Fields> & ValidatePostgresSchemaFields<Fields>,
+    ...options: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  ) => ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
   readonly enum: <
     Name extends string,
     const Values extends readonly [string, ...string[]]
   >(
-    name: Name,
+    name: BaseTable.NonEmptyStringInput<Name>,
     values: Values
   ) => EnumDefinition<Name, Values, SchemaName>
   readonly sequence: <
     Name extends string
   >(
-    name: Name
+    name: BaseTable.NonEmptyStringInput<Name>
   ) => SequenceDefinition<Name, SchemaName>
+  readonly withSchema: <
+    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,
+    Table[typeof BaseTable.TypeId]["conflictArbiters"][number]
+  >
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => SchemaNamespace<SchemaName>
 }
 
-export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
-): SchemaNamespace<SchemaName> => ({
-  ...makeTableSchemaNamespace(schemaName),
-  enum: <
+const SchemaProto = {
+  pipe(this: Pipeable) {
+    return pipeArguments(this, arguments)
+  }
+}
+
+export const make = <SchemaName extends string>(
+  schemaName: BaseTable.NonEmptyStringInput<SchemaName>,
+  options: { readonly casing?: Casing.Options } = {}
+): SchemaNamespace<SchemaName> => {
+  const physicalSchemaName = Casing.applyCategory(options.casing, "schemas", schemaName)
+  const namespace = Object.create(SchemaProto)
+  namespace.schemaName = schemaName
+  namespace.table = ((name: string, fields: any, ...declaredOptions: any[]) => {
+    let table = makeTable(name, fields, schemaName)
+    for (const option of declaredOptions) {
+      table = option(table)
+    }
+    return options.casing === undefined ? table : BaseTable.withCasing(table as any, options.casing)
+  }) as SchemaNamespace<SchemaName>["table"]
+  namespace.enum = <
     Name extends string,
     const Values extends readonly [string, ...string[]]
   >(
-    name: Name,
+    name: BaseTable.NonEmptyStringInput<Name>,
     values: Values
-  ) => enumType(name, values, schemaName) as EnumDefinition<Name, Values, SchemaName>,
-  sequence: <
+  ) => enumType(Casing.applyCategory(options.casing, "types", name), values, physicalSchemaName) as EnumDefinition<Name, Values, SchemaName>
+  namespace.sequence = <
     Name extends string
   >(
-    name: Name
-  ) => sequence(name, schemaName) as SequenceDefinition<Name, SchemaName>
-})
+    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, any>
+  >(table: Table & ValidatePostgresSchemaTable<Table>) => BaseTable.withSchema(table, schemaName, options.casing)
+  namespace[Casing.TypeId] = {
+    casing: options.casing
+  }
+  namespace.withCasing = (override: Casing.Options) =>
+    make(schemaName, { casing: Casing.merge(options.casing, override) })
+  return namespace as SchemaNamespace<SchemaName>
+}