effect-qb 0.15.0 → 0.17.0

package/src/postgres/json.ts

@@ -1,10 +1,12 @@
 import * as Expression from "../internal/scalar.js"
+import type * as ExpressionAst from "../internal/expression-ast.js"
 import type { JsonPathUsageError } from "../internal/json/errors.js"
 import * as JsonPath from "../internal/json/path.js"
 import type {
   JsonDeleteAtPath,
   JsonInsertAtPath,
   JsonSetAtPath,
+  JsonTextResult,
   JsonValueAtPath
 } from "../internal/json/types.js"
 import { json as postgresJson, jsonb as postgresJsonb } from "./internal/dsl.js"
@@ -75,6 +77,16 @@ type JsonSetOutputOf<
     ? JsonSetAtPath<Root, JsonPath.Path<[Target]>, Next, Operation>
     : never
 
+type JsonSetOutputWithCreateMissing<
+  Root,
+  Target extends JsonPath.Path<any> | JsonPath.CanonicalSegment,
+  Next,
+  Operation extends string,
+  CreateMissing extends boolean
+> = false extends CreateMissing
+  ? Root | JsonSetOutputOf<Root, Target, Next, Operation>
+  : JsonSetOutputOf<Root, Target, Next, Operation>
+
 type JsonInsertOutputOf<
   Root,
   Target extends JsonPath.Path<any> | JsonPath.CanonicalSegment,
@@ -144,17 +156,37 @@ type JsonNullabilityOf<Output> =
     ? Exclude<Output, null> extends never ? "always" : "maybe"
     : "never"
 
+type JsonPathSegmentsOf<Target extends JsonPath.Path<any> | JsonPath.CanonicalSegment> =
+  Target extends JsonPath.Path<infer Segments extends readonly JsonPath.CanonicalSegment[]> ? Segments :
+    Target extends JsonPath.CanonicalSegment ? readonly [Target] :
+      readonly []
+
+type JsonGetAccessKind<Target extends JsonPath.Path<any> | JsonPath.CanonicalSegment> =
+  Target extends JsonPath.Path<any>
+    ? JsonPath.IsExactPath<Target> extends true ? "jsonPath" : "jsonTraverse"
+    : Target extends JsonPath.ExactSegment ? "jsonGet" : "jsonAccess"
+
+type JsonTextAccessKind<Target extends JsonPath.Path<any> | JsonPath.CanonicalSegment> =
+  Target extends JsonPath.Path<any>
+    ? JsonPath.IsExactPath<Target> extends true ? "jsonPathText" : "jsonTraverseText"
+    : Target extends JsonPath.ExactSegment ? "jsonGetText" : "jsonAccessText"
+
 type JsonResultExpression<
   Runtime,
-  Db extends Expression.DbType.Json<any, any>
+  Db extends Expression.DbType.Json<any, any>,
+  Kind extends Expression.ScalarKind = Expression.ScalarKind,
+  Dependencies extends Expression.BindingId = Expression.BindingId,
+  Ast extends ExpressionAst.Any = never
 > = Expression.Scalar<
   Runtime,
   Db,
   JsonNullabilityOf<Runtime>,
   string,
-  Expression.ScalarKind,
-  Expression.BindingId
->
+  Kind,
+  Dependencies
+> & ([Ast] extends [never] ? unknown : {
+  readonly [ExpressionAst.TypeId]: Ast
+})
 
 type JsonDbOf<Base extends PostgresJsonExpression<any>> =
   Expression.DbTypeOf<Base> extends Expression.DbType.Json<"postgres", infer Variant>
@@ -167,14 +199,17 @@ type JsonGetResultExpression<
   Operation extends string
 > = JsonResultExpression<
   JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, Operation>,
-  JsonDbOf<Base>
+  JsonDbOf<Base>,
+  Expression.KindOf<Base>,
+  Expression.DependenciesOf<Base>,
+  ExpressionAst.JsonAccessNode<JsonGetAccessKind<Target>, Base, JsonPathSegmentsOf<Target>>
 >
 
 type JsonTextRuntime<
   Base extends PostgresJsonExpression<any>,
   Target extends JsonPath.Path<any> | JsonPath.CanonicalSegment
 > =
-  Extract<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.text">, string> |
+  JsonTextResult<Exclude<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.text">, JsonPathUsageError<any, any, any, any> | null>> |
   (null extends JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.text"> ? null : never)
 
 type JsonTextResultExpression<
@@ -185,9 +220,11 @@ type JsonTextResultExpression<
   Expression.DbType.Base<"postgres", "text">,
   JsonNullabilityOf<JsonTextRuntime<Base, Target>>,
   string,
-  Expression.ScalarKind,
-  Expression.BindingId
->
+  Expression.KindOf<Base>,
+  Expression.DependenciesOf<Base>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.JsonAccessNode<JsonTextAccessKind<Target>, Base, JsonPathSegmentsOf<Target>>
+}
 
 const exactPath = <Segments extends readonly JsonPath.CanonicalSegment[]>(
   ...segments: Segments & ExactJsonPathSegmentsGuard<Segments>
@@ -222,7 +259,7 @@ const json = {
     typeof jsonGetDirect & {
       <Target extends ExactJsonPathInput>(
         target: Target & ExactJsonPathGuard<Target>
-      ): <Base extends PostgresJsonExpression<any>>(base: Base) => ReturnType<typeof jsonGetDirect>
+      ): <Base extends PostgresJsonExpression<any>>(base: Base) => JsonGetResultExpression<Base, Target, "json.get">
     },
   access: <
     Base extends PostgresJsonExpression<any>,
@@ -245,7 +282,7 @@ const json = {
     typeof jsonTextDirect & {
       <Target extends ExactJsonPathInput>(
         target: Target & ExactJsonPathGuard<Target>
-      ): <Base extends PostgresJsonExpression<any>>(base: Base) => ReturnType<typeof jsonTextDirect>
+      ): <Base extends PostgresJsonExpression<any>>(base: Base) => JsonTextResultExpression<Base, Target>
     },
   accessText: <
     Base extends PostgresJsonExpression<any>,
@@ -416,17 +453,20 @@ const jsonb = {
   set: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>,
-    Next extends Parameters<typeof postgresJsonb.set>[2]
+    Next extends Parameters<typeof postgresJsonb.set>[2],
+    CreateMissing extends boolean = true
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.set">,
-    target: Target & JsonSetPathGuard<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
+    target: Target & JsonSetPathGuard<Expression.RuntimeOf<Base>, Target, NoInfer<Next>, "json.set">,
     next: Next,
-    options?: Parameters<typeof postgresJsonb.set>[3]
+    options?: {
+      readonly createMissing?: CreateMissing
+    }
   ): JsonResultExpression<
-    JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
+    JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>,
     Expression.DbTypeOf<Base>
   > => postgresJsonb.set(base as any, target as any, next, options) as unknown as JsonResultExpression<
-    JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
+    JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>,
     Expression.DbTypeOf<Base>
   >,
   insert: <
@@ -436,7 +476,7 @@ const jsonb = {
     InsertAfter extends boolean = false
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.insert">,
-    target: Target & JsonInsertPathGuard<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">,
+    target: Target & JsonInsertPathGuard<Expression.RuntimeOf<Base>, Target, NoInfer<Next>, NoInfer<InsertAfter>, "json.insert">,
     next: Next,
     options?: {
       readonly insertAfter?: InsertAfter

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,4 +1,5 @@
 import * as CoreRenderer from "../internal/renderer.js"
+import type * as Expression from "../internal/scalar.js"
 import { renderPostgresPlan } from "./internal/renderer.js"
 
 /** Postgres-specialized rendered query shape. */
@@ -8,12 +9,16 @@ export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
 /** Postgres-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"postgres">
 
+export interface MakeOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
 export { TypeId } from "../internal/renderer.js"
 export type { Projection } from "../internal/renderer.js"
 
 /** Creates the built-in Postgres renderer. */
-export const make = (): Renderer =>
-  CoreRenderer.make("postgres", renderPostgresPlan)
+export const make = (options: MakeOptions = {}): Renderer =>
+  CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, options))
 
 /** Shared built-in Postgres renderer instance. */
 export const postgres = make()

package/src/postgres/schema-management.ts

@@ -16,6 +16,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 +93,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,6 +102,24 @@ 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) {
     return pipeArguments(this, arguments)
@@ -45,7 +132,7 @@ const EnumProto = {
   type(this: EnumDefinition) {
     return {
       dialect: "postgres",
-      kind: this.qualifiedName(),
+      kind: renderQualifiedTypeName(this.name, this.schemaName),
       variant: "enum"
     }
   },
@@ -61,7 +148,7 @@ const EnumProto = {
         primaryKey: false,
         unique: false,
         references: undefined,
-        ddlType: this.qualifiedName(),
+        ddlType: renderQualifiedTypeName(this.name, this.schemaName),
         identity: undefined,
         enum: {
           name: this.name,
@@ -99,7 +186,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>
 }
 

package/src/postgres/schema.ts

@@ -1,4 +1,4 @@
-import { schema as makeTableSchemaNamespace, type TableSchemaNamespace } from "../internal/table.js"
+import { schema as makeTableSchemaNamespace, type TableSchemaNamespace } from "./table.js"
 import { enumType, sequence, type EnumDefinition, type SequenceDefinition } from "./schema-management.js"
 
 export type SchemaNamespace<SchemaName extends string> = TableSchemaNamespace<SchemaName> & {