effect-qb 0.16.0 → 0.19.0

package/src/postgres/internal/renderer.ts

@@ -1,9 +1,10 @@
 import * as Query from "../../internal/query.js"
 import type * as Expression from "../../internal/scalar.js"
+import type * as Casing from "../../internal/casing.js"
 import { type RenderState } from "../../internal/dialect.js"
 import { postgresDialect } from "./dialect.js"
 import { type Projection } from "../../internal/projections.js"
-import { renderQueryAst } from "./sql-expression-renderer.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
 
 /**
  * Minimal rendered-query payload produced by the built-in Postgres renderer.
@@ -20,6 +21,7 @@ export interface PostgresRenderResult {
 
 export interface PostgresRenderOptions {
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
 }
 
 /**
@@ -32,8 +34,11 @@ export const renderPostgresPlan = <PlanValue extends Query.Plan.Any>(
   const state: RenderState = {
     params: [],
     valueMappings: options.valueMappings,
+    casing: options.casing,
     ctes: [],
-    cteNames: new Set<string>()
+    cteNames: new Set<string>(),
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
   }
   const rendered = renderQueryAst(
     Query.getAst(plan as Query.Plan.Any) as any,

package/src/postgres/internal/schema-ddl.ts

@@ -1,7 +1,7 @@
 import type * as Expression from "../../internal/scalar.js"
 import type { RenderState, SqlDialect } from "../../internal/dialect.js"
 import * as SchemaExpression from "../../internal/schema-expression.js"
-import { renderExpression } from "./sql-expression-renderer.js"
+import { renderExpression } from "../../internal/sql-expression-renderer.js"
 import type { DdlExpressionLike } from "../../internal/table-options.js"
 import { parse, toSql } from "pgsql-ast-parser"
 import { postgresDialect } from "./dialect.js"
@@ -30,20 +30,30 @@ const inlineLiteralDialect: SqlDialect<"postgres"> = {
       return String(value)
     }
     if (value instanceof Date) {
+      if (Number.isNaN(value.getTime())) {
+        throw new Error("Expected a valid Date value")
+      }
       return escapeString(value.toISOString())
     }
     return escapeString(String(value))
   }
 }
 
-export const renderDdlExpressionSql = (expression: DdlExpressionLike): string =>
+const makeExpressionState = (state: Partial<RenderState> = {}): RenderState => ({
+  ...state,
+  params: [],
+  ctes: [],
+  cteNames: new Set(),
+  cteSources: new Map()
+})
+
+export const renderDdlExpressionSql = (
+  expression: DdlExpressionLike,
+  state?: Partial<RenderState>
+): string =>
   SchemaExpression.isSchemaExpression(expression)
     ? SchemaExpression.render(expression)
-    : renderExpression(expression as Expression.Any, {
-        params: [],
-        ctes: [],
-        cteNames: new Set()
-      }, inlineLiteralDialect)
+    : renderExpression(expression as Expression.Any, makeExpressionState(state), inlineLiteralDialect)
 
 const stripRedundantOuterParens = (value: string): string => {
   let current = value.trim()
@@ -98,8 +108,11 @@ const canonicalizeDdlExpressionSql = (value: string): string =>
       )
   )
 
-export const normalizeDdlExpressionSql = (expression: DdlExpressionLike): string => {
-  const rendered = renderDdlExpressionSql(expression)
+export const normalizeDdlExpressionSql = (
+  expression: DdlExpressionLike,
+  state?: Partial<RenderState>
+): string => {
+  const rendered = renderDdlExpressionSql(expression, state)
   try {
     return canonicalizeDdlExpressionSql(toSql.expr(parse(rendered, "expr")))
   } catch {

package/src/postgres/internal/schema-model.ts

@@ -1,7 +1,11 @@
 import * as Table from "../../internal/table.js"
 import type { AnyColumnDefinition } from "../../internal/column-state.js"
+import type { RenderState } from "../../internal/dialect.js"
+import * as Casing from "../../internal/casing.js"
+import * as Expression from "../../internal/scalar.js"
+import * as SchemaExpression from "../../internal/schema-expression.js"
 import { normalizeDdlExpressionSql } from "./schema-ddl.js"
-import type { TableOptionSpec } from "../../internal/table-options.js"
+import { validateOptions, type ColumnList, type DdlExpressionLike, type IndexKeySpec, type TableOptionSpec } from "../../internal/table-options.js"
 import type { EnumDefinition } from "../schema-management.js"
 import { EnumTypeId } from "../schema-management.js"
 
@@ -52,15 +56,238 @@ export const isTableDefinition = (value: unknown): value is Table.AnyTable =>
 export const isEnumDefinition = (value: unknown): value is EnumDefinition =>
   typeof value === "object" && value !== null && EnumTypeId in value
 
+const applyCasing = (
+  casing: Casing.Options | undefined,
+  category: Casing.Category,
+  name: string
+): string =>
+  Casing.applyCategory(casing, category, name)
+
+const mapColumnList = (
+  columns: ColumnList,
+  casing: Casing.Options | undefined
+): ColumnList =>
+  !Array.isArray(columns)
+    ? columns
+    : columns.length === 0
+      ? columns
+      : [
+          mapCasedValue(columns[0], casing, "columns"),
+          ...columns.slice(1).map((column) => mapCasedValue(column, casing, "columns"))
+        ] as ColumnList
+
+const expressionStateForTable = (
+  state: Table.AnyTable[typeof Table.TypeId],
+  tableName: string,
+  columns: ReadonlyMap<string, string>,
+  casing: Casing.Options | undefined
+): Partial<RenderState> => ({
+  casing,
+  rowLocalColumns: true,
+  sourceNames: new Map([
+    [state.name, { tableName, columns }],
+    [state.baseName, { tableName, columns }]
+  ])
+})
+
+const mapDdlExpression = (
+  expression: DdlExpressionLike,
+  state: Partial<RenderState>
+): SchemaExpression.SchemaExpression =>
+  SchemaExpression.fromSql(normalizeDdlExpressionSql(expression, state))
+
+function mapOptionName(
+  name: string,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): string
+function mapOptionName(
+  name: unknown,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): unknown
+function mapOptionName(
+  name: unknown,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): unknown {
+  return typeof name === "string"
+    ? applyCasing(casing, category, name)
+    : name
+}
+
+function mapCasedValue(
+  value: string,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): string
+function mapCasedValue(
+  value: unknown,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): unknown
+function mapCasedValue(
+  value: unknown,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): unknown {
+  return typeof value === "string"
+    ? applyCasing(casing, category, value)
+    : value
+}
+
+const isDdlExpressionLike = (value: unknown): value is DdlExpressionLike =>
+  typeof value === "object" &&
+  value !== null &&
+  (Expression.TypeId in value || SchemaExpression.TypeId in value)
+
+function mapIndexKey(
+  key: IndexKeySpec,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): IndexKeySpec
+function mapIndexKey(
+  key: unknown,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): unknown
+function mapIndexKey(
+  key: unknown,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): unknown {
+  if (typeof key !== "object" || key === null || !("kind" in key)) {
+    return key
+  }
+  const kind = (key as { readonly kind?: unknown }).kind
+  if (kind === "column") {
+    const column = (key as { readonly column?: unknown }).column
+    return typeof column === "string"
+      ? {
+          ...key,
+          column: applyCasing(casing, "columns", column)
+        }
+      : key
+  }
+  if (kind === "expression") {
+    const expression = (key as { readonly expression?: unknown }).expression
+    return isDdlExpressionLike(expression)
+      ? {
+          ...key,
+          expression: mapDdlExpression(expression, expressionState)
+        }
+      : key
+  }
+  return key
+}
+
+const mapOption = (
+  option: TableOptionSpec,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): TableOptionSpec => {
+  switch (option.kind) {
+    case "index":
+      return {
+        ...option,
+        columns: option.columns === undefined ? undefined : mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "indexes"),
+        include: option.include === undefined
+          ? undefined
+          : Array.isArray(option.include)
+            ? option.include.map((column) => mapCasedValue(column, casing, "columns")) as unknown as readonly string[]
+            : option.include,
+        predicate: option.predicate === undefined
+          ? undefined
+          : isDdlExpressionLike(option.predicate)
+            ? mapDdlExpression(option.predicate, expressionState)
+            : option.predicate,
+        keys: option.keys === undefined
+          ? undefined
+          : Array.isArray(option.keys)
+            ? option.keys.length === 0
+              ? option.keys
+              : [
+                  mapIndexKey(option.keys[0], casing, expressionState),
+                  ...option.keys.slice(1).map((key) => mapIndexKey(key, casing, expressionState))
+                ] as unknown as readonly [IndexKeySpec, ...IndexKeySpec[]]
+            : option.keys
+      }
+    case "primaryKey":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints")
+      }
+    case "unique":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints")
+      }
+    case "foreignKey":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints"),
+        references: () => {
+          const reference = typeof option.references === "function"
+            ? option.references()
+            : option.references
+          if (typeof reference !== "object" || reference === null) {
+            return reference
+          }
+          const referenceCasing = reference.casing
+          return {
+            ...reference,
+            tableName: mapCasedValue(reference.tableName, referenceCasing, "tables"),
+            schemaName: reference.schemaName === undefined
+              ? undefined
+              : mapCasedValue(reference.schemaName, referenceCasing, "schemas"),
+            columns: mapColumnList(reference.columns, referenceCasing),
+            knownColumns: reference.knownColumns === undefined
+              ? undefined
+              : Array.isArray(reference.knownColumns)
+                ? reference.knownColumns.map((column) =>
+                  mapCasedValue(column, referenceCasing, "columns")) as unknown as readonly string[]
+                : reference.knownColumns
+          }
+        }
+      }
+    case "check":
+      return {
+        ...option,
+        name: mapOptionName(option.name, casing, "constraints"),
+        predicate: isDdlExpressionLike(option.predicate)
+          ? mapDdlExpression(option.predicate, expressionState)
+          : option.predicate
+      }
+    default:
+      return option
+  }
+}
+
 export const toTableModel = (table: Table.AnyTable): TableModel => {
   const state = table[Table.TypeId]
+  const casing = state.casing
+  const tableName = applyCasing(casing, "tables", state.baseName)
+  const schemaName = state.schemaName === undefined
+    ? undefined
+    : applyCasing(casing, "schemas", state.schemaName)
   const fields = state.fields as Record<string, AnyColumnDefinition>
+  const options = table[Table.OptionsSymbol] as unknown
+  const normalizedOptions = (Array.isArray(options) ? options : [options]) as readonly TableOptionSpec[]
+  validateOptions(state.name, fields, normalizedOptions)
+  const columnNames = new Map(
+    Object.keys(fields).map((name) => [name, applyCasing(casing, "columns", name)] as const)
+  )
+  const expressionState = expressionStateForTable(state, tableName, columnNames, casing)
   const columns = Object.entries(fields).map(([name, column]) => {
     const metadata = column.metadata
     const enumDefinition = metadata.enum
     const ddlType = metadata.ddlType ?? metadata.dbType.kind
     return {
-      name,
+      name: columnNames.get(name) ?? name,
       ddlType,
       dbTypeKind: enumDefinition?.name ?? column.metadata.dbType.kind,
       typeKind: enumDefinition === undefined ? undefined : "e",
@@ -70,20 +297,24 @@ export const toTableModel = (table: Table.AnyTable): TableModel => {
       generated: column.metadata.generated,
       defaultSql: column.metadata.defaultValue === undefined
         ? undefined
-        : normalizeDdlExpressionSql(column.metadata.defaultValue),
+        : normalizeDdlExpressionSql(column.metadata.defaultValue, expressionState),
       generatedSql: column.metadata.generatedValue === undefined
         ? undefined
-        : normalizeDdlExpressionSql(column.metadata.generatedValue),
+        : normalizeDdlExpressionSql(column.metadata.generatedValue, expressionState),
       identity: column.metadata.identity,
       column
     }
   }) satisfies ReadonlyArray<ColumnModel>
   return {
     kind: "table",
-    schemaName: state.schemaName,
-    name: state.baseName,
+    schemaName,
+    name: tableName,
     columns,
-    options: table[Table.OptionsSymbol],
+    options: normalizedOptions.map((option) =>
+      typeof option === "object" && option !== null && "kind" in option
+        ? mapOption(option, casing, expressionState)
+        : option as TableOptionSpec
+    ),
     table
   }
 }
@@ -121,17 +352,17 @@ export const fromDiscoveredValues = (values: ReadonlyArray<unknown>): SchemaMode
   const enums = new Map<string, EnumModel>()
   for (const value of values) {
     if (isEnumDefinition(value)) {
-      enums.set(enumKey(value.schemaName, value.name), toEnumModel(value))
+      enums.set(modelIdentityKey(value.schemaName, value.name), toEnumModel(value))
     } else if (isTableDefinition(value)) {
       for (const enumModel of enumModelsOfTable(value)) {
-        const key = enumKey(enumModel.schemaName, enumModel.name)
+        const key = modelIdentityKey(enumModel.schemaName, enumModel.name)
         const existing = enums.get(key)
         if (existing === undefined) {
           enums.set(key, enumModel)
           continue
         }
         if (JSON.stringify(existing.values) !== JSON.stringify(enumModel.values)) {
-          throw new Error(`Conflicting enum definitions discovered for '${key}'`)
+          throw new Error(`Conflicting enum definitions discovered for '${enumKey(enumModel.schemaName, enumModel.name)}'`)
         }
       }
     }
@@ -148,3 +379,6 @@ export const tableKey = (schemaName: string | undefined, name: string): string =
 
 export const enumKey = (schemaName: string | undefined, name: string): string =>
   `${schemaName ?? "public"}.${name}`
+
+const modelIdentityKey = (schemaName: string | undefined, name: string): string =>
+  JSON.stringify([schemaName ?? "public", name])

package/src/postgres/json.ts

@@ -1,17 +1,20 @@
 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 type { LiteralStringInput } from "../internal/table-options.js"
 import { json as postgresJson, jsonb as postgresJsonb } from "./internal/dsl.js"
 
 type PostgresJsonExpression<Runtime = unknown> = Expression.Scalar<
   Runtime,
-  Expression.DbType.Json<"postgres", "json" | "jsonb">,
+  Expression.DbType.Json<"postgres" | "standard", "json" | "jsonb">,
   Expression.Nullability,
   string,
   Expression.ScalarKind,
@@ -29,10 +32,24 @@ type PostgresJsonbExpression<Runtime = unknown> = Expression.Scalar<
 
 type ExactJsonPathInput = JsonPath.ExactSegment | JsonPath.Path<any>
 
+type JsonPathPredicateExpression = Expression.Scalar<
+  string | null,
+  Expression.DbType.Any,
+  Expression.Nullability,
+  string,
+  Expression.ScalarKind,
+  Expression.BindingId
+>
+
+type JsonPathPredicateQuery = JsonPath.Path<any> | JsonPathPredicateExpression | string
+
+type JsonPathPredicateQueryInput<Query extends JsonPathPredicateQuery> =
+  Query extends string ? LiteralStringInput<Query> : Query
+
 type ExactJsonPathUsageError<Target> = {
   readonly __effect_qb_error__: "effect-qb: postgres json helpers only accept exact key/index paths"
   readonly __effect_qb_json_path__: Target
-  readonly __effect_qb_hint__: "Use Postgres.Json.jsonb.path(...) when you need wildcard(), slice(), or descend() segments"
+  readonly __effect_qb_hint__: "Use Postgres.Jsonb.path(...) when you need wildcard(), slice(), or descend() segments"
 }
 
 type ExactJsonPathGuard<Target> = Target extends JsonPath.Path<any>
@@ -75,6 +92,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,
@@ -129,7 +156,7 @@ type JsonbOnlyUsageError<
   readonly __effect_qb_error__: "effect-qb: postgres jsonb helpers require a jsonb expression"
   readonly __effect_qb_json_operation__: Operation
   readonly __effect_qb_received_kind__: Expression.DbTypeOf<Value>["kind"]
-  readonly __effect_qb_hint__: "Use Column.jsonb(...), Cast.to(..., Type.jsonb()), or Postgres.Json.jsonb.toJsonb(...)"
+  readonly __effect_qb_hint__: "Use Column.jsonb(...), Cast.to(..., Type.jsonb()), or Postgres.Jsonb.toJsonb(...)"
 }
 
 type JsonbBaseGuard<
@@ -144,17 +171,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 +214,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 +235,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 +274,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 +297,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 +468,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 +491,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
@@ -474,20 +529,41 @@ const jsonb = {
     base: Base & JsonbBaseGuard<Base, "jsonb.stripNulls">
   ) => postgresJsonb.stripNulls(base as Base),
   pathExists: <
-    Base extends PostgresJsonExpression<any>
+    Base extends PostgresJsonExpression<any>,
+    Query extends JsonPathPredicateQuery
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.pathExists">,
-    query: Parameters<typeof postgresJsonb.pathExists>[1]
+    query: JsonPathPredicateQueryInput<Query>
   ) => postgresJsonb.pathExists(base as Base, query),
   pathMatch: <
-    Base extends PostgresJsonExpression<any>
+    Base extends PostgresJsonExpression<any>,
+    Query extends JsonPathPredicateQuery
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.pathMatch">,
-    query: Parameters<typeof postgresJsonb.pathMatch>[1]
+    query: JsonPathPredicateQueryInput<Query>
   ) => postgresJsonb.pathMatch(base as Base, query)
 }
 
 /** Postgres shared JSON helpers for exact paths and functions that work on both json and jsonb. */
 export { json }
+export const key = json.key
+export const index = json.index
+export const path = json.path
+export const get = json.get
+export const access = json.access
+export const traverse = json.traverse
+export const text = json.text
+export const accessText = json.accessText
+export const traverseText = json.traverseText
+export const buildObject = json.buildObject
+export const buildArray = json.buildArray
+export const toJson = json.toJson
+export const typeOf = json.typeOf
+export const length = json.length
+export const keys = json.keys
+export const stripNulls = json.stripNulls
+export const delete_ = json.delete
+export { delete_ as delete }
+export const remove = json.remove
 /** Postgres jsonb-only helpers for containment, mutation, wildcard paths, and SQL/JSON path predicates. */
 export { jsonb }

package/src/postgres/jsonb.ts

@@ -0,0 +1,38 @@
+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 path = jsonb.path
+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