effect-qb 0.16.0 → 0.19.0

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

@@ -16,7 +16,6 @@ import {
   type HavingPredicateInput,
   type OrderDirection,
   type OutputOfSelection,
-  type MutationInputOf,
   type MutationTargetLike,
   type NumericExpressionInput,
   type PredicateInput,
@@ -137,9 +136,18 @@ export {
   orderBy,
   groupBy
 } from "./internal/dsl.js"
+import type * as Expression from "../internal/scalar.js"
 export { postgresType as type }
 export const generateSeries: PublicGenerateSeriesApi = dslGenerateSeries as PublicGenerateSeriesApi
 
+type PostgresMutationValueInput<Value> =
+  | Value
+  | Expression.Scalar<Value, Expression.DbType.Any, Expression.Nullability, "postgres", Expression.ScalarKind, Expression.BindingId>
+
+export type MutationInputOf<Shape> = {
+  readonly [K in keyof Shape]: PostgresMutationValueInput<Shape[K]>
+}
+
 type StructuredSource = AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource
 
 type StructuredFromApi = <CurrentSource extends StructuredSource>(
@@ -165,7 +173,6 @@ export type {
   HavingPredicateInput,
   OrderDirection,
   OutputOfSelection,
-  MutationInputOf,
   MutationTargetLike,
   NumericExpressionInput,
   PredicateInput,

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,41 @@ 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
+  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. */
-export const make = (options: MakeOptions = {}): Renderer =>
-  CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, options))
+export const make = (options: MakeOptions = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(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 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")
@@ -16,6 +17,75 @@ type QualifiedName<
     : `${SchemaName}.${Name}`
   : Name
 
+type LowerAlpha =
+  | "a"
+  | "b"
+  | "c"
+  | "d"
+  | "e"
+  | "f"
+  | "g"
+  | "h"
+  | "i"
+  | "j"
+  | "k"
+  | "l"
+  | "m"
+  | "n"
+  | "o"
+  | "p"
+  | "q"
+  | "r"
+  | "s"
+  | "t"
+  | "u"
+  | "v"
+  | "w"
+  | "x"
+  | "y"
+  | "z"
+
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+type SafeIdentifierStart = LowerAlpha | "_"
+type SafeIdentifierRest = SafeIdentifierStart | Digit | "$"
+
+type EscapeIdentifier<Value extends string> =
+  Value extends `${infer Head}"${infer Tail}`
+    ? `${Head}""${EscapeIdentifier<Tail>}`
+    : Value
+
+type IsSafeIdentifierRest<Value extends string> =
+  Value extends ""
+    ? true
+    : Value extends `${infer Head}${infer Tail}`
+      ? Head extends SafeIdentifierRest
+        ? IsSafeIdentifierRest<Tail>
+        : false
+      : false
+
+type IsSafeIdentifier<Value extends string> =
+  Value extends `${infer Head}${infer Tail}`
+    ? Head extends SafeIdentifierStart
+      ? IsSafeIdentifierRest<Tail>
+      : false
+    : false
+
+type RenderIdentifier<Value extends string> =
+  string extends Value
+    ? string
+    : IsSafeIdentifier<Value> extends true
+      ? Value
+      : `"${EscapeIdentifier<Value>}"`
+
+type RenderQualifiedTypeName<
+  Name extends string,
+  SchemaName extends string | undefined
+> = SchemaName extends string
+  ? SchemaName extends "public"
+    ? RenderIdentifier<Name>
+    : `${RenderIdentifier<SchemaName>}.${RenderIdentifier<Name>}`
+  : RenderIdentifier<Name>
+
 type EnumColumn<
   Name extends string,
   Values extends readonly [string, ...string[]],
@@ -24,7 +94,7 @@ type EnumColumn<
   Values[number],
   Values[number],
   Values[number],
-  Expression.DbType.Enum<"postgres", QualifiedName<Name, SchemaName>>,
+  Expression.DbType.Enum<"postgres", RenderQualifiedTypeName<Name, SchemaName>>,
   false,
   false,
   false,
@@ -33,8 +103,26 @@ type EnumColumn<
   undefined
 >
 
+const safeUnquotedIdentifier = /^[a-z_][a-z0-9_$]*$/
+
+const quoteIdentifier = (value: string): string =>
+  `"${value.replaceAll("\"", "\"\"")}"`
+
+const renderIdentifier = (value: string): string =>
+  safeUnquotedIdentifier.test(value)
+    ? value
+    : quoteIdentifier(value)
+
+const renderQualifiedTypeName = (
+  name: string,
+  schemaName: string | undefined
+): string =>
+  schemaName === undefined || schemaName === "public"
+    ? renderIdentifier(name)
+    : `${renderIdentifier(schemaName)}.${renderIdentifier(name)}`
+
 const EnumProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   },
   qualifiedName(this: EnumDefinition) {
@@ -45,12 +133,16 @@ const EnumProto = {
   type(this: EnumDefinition) {
     return {
       dialect: "postgres",
-      kind: this.qualifiedName(),
+      kind: renderQualifiedTypeName(this.name, this.schemaName),
       variant: "enum"
     }
   },
   column(this: EnumDefinition) {
-    const values = this.values.map((value) => Schema.Literal(value)) as unknown as readonly [Schema.Schema.Any, ...Schema.Schema.Any[]]
+    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),
       {
@@ -61,7 +153,7 @@ const EnumProto = {
         primaryKey: false,
         unique: false,
         references: undefined,
-        ddlType: this.qualifiedName(),
+        ddlType: renderQualifiedTypeName(this.name, this.schemaName),
         identity: undefined,
         enum: {
           name: this.name,
@@ -74,7 +166,7 @@ const EnumProto = {
 }
 
 const SequenceProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   },
   qualifiedName(this: SequenceDefinition) {
@@ -99,7 +191,7 @@ export interface EnumDefinition<
     readonly schemaName: SchemaName
   }
   readonly qualifiedName: () => QualifiedName<Name, SchemaName>
-  readonly type: () => Expression.DbType.Enum<"postgres", QualifiedName<Name, SchemaName>>
+  readonly type: () => Expression.DbType.Enum<"postgres", RenderQualifiedTypeName<Name, SchemaName>>
   readonly column: () => EnumColumn<Name, Values, SchemaName>
 }
 
@@ -125,7 +217,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<
@@ -133,9 +225,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,
@@ -156,11 +248,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,
@@ -178,21 +270,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,118 @@
-import { schema as makeTableSchemaNamespace, type TableSchemaNamespace } from "../internal/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>
+  ? BaseTable.TableDefinition<Name, Fields, AppliedPrimaryKeyColumns, "schema", SchemaName>
+  : 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>
+  : 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>
+  >(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
+  >
+  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>
+  >(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>
+}