effect-qb 0.17.0 → 0.20.0

package/src/postgres/executor.ts

@@ -1,11 +1,12 @@
 import * as Effect from "effect/Effect"
-import * as SqlClient from "@effect/sql/SqlClient"
+import * as SqlClient from "effect/unstable/sql/SqlClient"
 import * as Stream from "effect/Stream"
 
 import * as CoreExecutor from "../internal/executor.js"
 import * as CoreQuery from "../internal/query.js"
 import * as CoreRenderer from "../internal/renderer.js"
 import type * as Expression from "../internal/scalar.js"
+import type { PostgresDatatypeFamily, PostgresDatatypeKind } from "./datatypes/spec.js"
 import { renderPostgresPlan } from "./internal/renderer.js"
 import {
   narrowPostgresDriverErrorForReadQuery,
@@ -24,12 +25,13 @@ export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"postgr
 export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"postgres", Error, Context>
 /** Postgres-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"postgres">
+export type ValueMappings = Expression.DriverValueMappingsFor<PostgresDatatypeKind, PostgresDatatypeFamily>
 /** Optional renderer / driver overrides for the standard Postgres executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
   readonly renderer?: Renderer
   readonly driver?: Driver<Error, Context>
   readonly driverMode?: CoreExecutor.DriverMode
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
 }
 /** Standard composed error shape for Postgres executors. */
 export type PostgresExecutorError = PostgresDriverError | RowDecodeError
@@ -39,8 +41,6 @@ export type PostgresQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, a
 
 /** Runs an effect within the ambient Postgres SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
-/** Runs an effect in a nested Postgres SQL transaction scope. */
-export const withSavepoint = CoreExecutor.withSavepoint
 
 /** Postgres executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
@@ -140,10 +140,10 @@ const fromDriver = <
   stream(plan) {
     const rendered = renderer.render(plan)
     return Stream.mapError(
-      Stream.mapChunksEffect(
+      Stream.mapArrayEffect(
         sqlDriver.stream(rendered),
         (rows) => Effect.try({
-          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
           catch: (error) => error as RowDecodeError
         })
       ),
@@ -173,7 +173,7 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
  * Creates the standard Postgres executor pipeline.
  *
  * By default this uses the built-in Postgres renderer plus the ambient
- * `@effect/sql` `SqlClient`. Advanced callers can override the renderer,
+ * `effect/unstable/sql` `SqlClient`. Advanced callers can override the renderer,
  * driver, or both.
  */
 export function make(): QueryExecutor<SqlClient.SqlClient>
@@ -181,7 +181,7 @@ export function make(
   options: {
     readonly renderer?: Renderer
     readonly driverMode?: CoreExecutor.DriverMode
-    readonly valueMappings?: Expression.DriverValueMappings
+    readonly valueMappings?: ValueMappings
   }
 ): QueryExecutor<SqlClient.SqlClient>
 export function make<Error = never, Context = never>(
@@ -189,7 +189,7 @@ export function make<Error = never, Context = never>(
     readonly renderer?: Renderer
     readonly driver: Driver<Error, Context>
     readonly driverMode?: CoreExecutor.DriverMode
-    readonly valueMappings?: Expression.DriverValueMappings
+    readonly valueMappings?: ValueMappings
   }
 ): QueryExecutor<Context>
 export function make<Error = never, Context = never>(
@@ -197,14 +197,14 @@ export function make<Error = never, Context = never>(
 ): QueryExecutor<any> {
   if (options.driver) {
     return fromDriver(
-      options.renderer ?? CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
+      options.renderer ?? CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
       options.driver,
       options.driverMode,
       options.valueMappings
     )
   }
   return fromDriver(
-    options.renderer ?? CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
+    options.renderer ?? CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
     sqlClientDriver(),
     options.driverMode,
     options.valueMappings

package/src/postgres/foreign-key.ts

@@ -0,0 +1,24 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type ForeignKeySpec = Extract<TableOptionSpec, { readonly kind: "foreignKey" }>
+
+export const deferrable = <Spec extends ForeignKeySpec, 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 ForeignKeySpec, 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/function/core.ts

@@ -1,8 +1,6 @@
 import type { ExpressionInput } from "../query.js"
 import {
-  call,
   cast,
-  coalesce,
   literal,
   nextVal as nextValInternal,
   type as postgresType,
@@ -11,7 +9,7 @@ import {
 import { isSequenceDefinition, type SequenceDefinition } from "../schema-management.js"
 
 /** Postgres scalar core functions. */
-export { coalesce, call, uuidGenerateV4 }
+export { uuidGenerateV4 }
 
 const safeUnquotedIdentifier = /^[a-z_][a-z0-9_$]*$/
 

package/src/postgres/function/index.ts

@@ -1,19 +1,3 @@
 export * as core from "./core.js"
-export * as string from "./string.js"
-export * as aggregate from "./aggregate.js"
-export * as window from "./window.js"
-export * as temporal from "./temporal.js"
 
-export { coalesce } from "./core.js"
-export { call, uuidGenerateV4, nextVal } from "./core.js"
-export { lower, upper, concat } from "./string.js"
-export { count, max, min } from "./aggregate.js"
-export { over, rowNumber, rank, denseRank } from "./window.js"
-export {
-  currentDate,
-  currentTime,
-  currentTimestamp,
-  localTime,
-  localTimestamp,
-  now
-} from "./temporal.js"
+export { uuidGenerateV4, nextVal } from "./core.js"

package/src/postgres/function/temporal.ts

@@ -39,7 +39,7 @@ const makeTemporal = <
 >(
   name: Name,
   dbType: Db,
-  runtimeSchema: Schema.Schema<Runtime, any, any>
+  runtimeSchema: Schema.Schema<Runtime>
 ): TemporalExpression<Runtime, Db, Name> =>
   makeExpression({
     runtime: undefined as unknown as Runtime,

package/src/postgres/index.ts

@@ -0,0 +1 @@
+export { include, key, keys, uniqueIndex, using, where } from "./table.js"

package/src/postgres/internal/dialect.ts

@@ -1,7 +1,9 @@
-import type { RenderState, RenderValueContext, SqlDialect } from "../../internal/dialect.js"
+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"
+import { standardDialect } from "../../standard/dialect.js"
 
-const quoteIdentifier = (value: string): string => `"${value.replaceAll("\"", "\"\"")}"`
+const quoteIdentifier = quoteDoubleQuotedIdentifier
 
 const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
   const driverValue = toDriverValue(value, {
@@ -23,11 +25,12 @@ const renderLiteral = (value: unknown, state: RenderState, context: RenderValueC
  * Built-in runtime dialect implementation for Postgres.
  */
 export const postgresDialect: SqlDialect<"postgres"> = {
+  ...standardDialect,
   name: "postgres",
   quoteIdentifier,
   renderLiteral,
   renderTableReference(tableName, baseTableName, schemaName) {
-    const renderedBase = schemaName
+    const renderedBase = schemaName && schemaName !== "public"
       ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
       : quoteIdentifier(baseTableName)
     return tableName === baseTableName
@@ -36,5 +39,7 @@ export const postgresDialect: SqlDialect<"postgres"> = {
   },
   renderConcat(values) {
     return `(${values.join(" || ")})`
-  }
+  },
+  renderQueryAst,
+  renderExpression
 }