effect-qb 0.14.0 → 0.15.0

package/src/postgres/{function/json.ts → json.ts}

@@ -1,34 +1,30 @@
-import * as Expression from "../../internal/expression.js"
-import type { JsonPathUsageError } from "../../internal/json/errors.js"
-import * as JsonPath from "../../internal/json/path.js"
+import * as Expression from "../internal/scalar.js"
+import type { JsonPathUsageError } from "../internal/json/errors.js"
+import * as JsonPath from "../internal/json/path.js"
 import type {
   JsonDeleteAtPath,
   JsonInsertAtPath,
   JsonSetAtPath,
   JsonValueAtPath
-} from "../../internal/json/types.js"
-import { postgresQuery } from "../private/query.js"
+} from "../internal/json/types.js"
+import { json as postgresJson, jsonb as postgresJsonb } from "./internal/dsl.js"
 
-type PostgresJsonExpression<Runtime = unknown> = Expression.Expression<
+type PostgresJsonExpression<Runtime = unknown> = Expression.Scalar<
   Runtime,
   Expression.DbType.Json<"postgres", "json" | "jsonb">,
   Expression.Nullability,
   string,
-  Expression.AggregationKind,
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.ScalarKind,
+  Expression.BindingId
 >
 
-type PostgresJsonbExpression<Runtime = unknown> = Expression.Expression<
+type PostgresJsonbExpression<Runtime = unknown> = Expression.Scalar<
   Runtime,
   Expression.DbType.Json<"postgres", "jsonb">,
   Expression.Nullability,
   string,
-  Expression.AggregationKind,
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.ScalarKind,
+  Expression.BindingId
 >
 
 type ExactJsonPathInput = JsonPath.ExactSegment | JsonPath.Path<any>
@@ -36,7 +32,7 @@ type ExactJsonPathInput = JsonPath.ExactSegment | JsonPath.Path<any>
 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.Function.jsonb.path(...) when you need wildcard(), slice(), or descend() segments"
+  readonly __effect_qb_hint__: "Use Postgres.Json.jsonb.path(...) when you need wildcard(), slice(), or descend() segments"
 }
 
 type ExactJsonPathGuard<Target> = Target extends JsonPath.Path<any>
@@ -133,7 +129,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.Function.jsonb.toJsonb(...)"
+  readonly __effect_qb_hint__: "Use Column.jsonb(...), Cast.to(..., Type.jsonb()), or Postgres.Json.jsonb.toJsonb(...)"
 }
 
 type JsonbBaseGuard<
@@ -151,15 +147,13 @@ type JsonNullabilityOf<Output> =
 type JsonResultExpression<
   Runtime,
   Db extends Expression.DbType.Json<any, any>
-> = Expression.Expression<
+> = Expression.Scalar<
   Runtime,
   Db,
   JsonNullabilityOf<Runtime>,
   string,
-  Expression.AggregationKind,
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.ScalarKind,
+  Expression.BindingId
 >
 
 type JsonDbOf<Base extends PostgresJsonExpression<any>> =
@@ -186,15 +180,13 @@ type JsonTextRuntime<
 type JsonTextResultExpression<
   Base extends PostgresJsonExpression<any>,
   Target extends JsonPath.Path<any> | JsonPath.CanonicalSegment
-> = Expression.Expression<
+> = Expression.Scalar<
   JsonTextRuntime<Base, Target>,
-  Expression.DbType.PgText,
+  Expression.DbType.Base<"postgres", "text">,
   JsonNullabilityOf<JsonTextRuntime<Base, Target>>,
   string,
-  Expression.AggregationKind,
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Expression.ScalarKind,
+  Expression.BindingId
 >
 
 const exactPath = <Segments extends readonly JsonPath.CanonicalSegment[]>(
@@ -208,7 +200,7 @@ const jsonGetDirect = <
   base: Base,
   target: Target & ExactJsonPathGuard<Target>
 ): JsonGetResultExpression<Base, Target, "json.get"> =>
-  postgresQuery.json.get(base as never, target as never) as unknown as JsonGetResultExpression<Base, Target, "json.get">
+  postgresJson.get(base as never, target as never) as unknown as JsonGetResultExpression<Base, Target, "json.get">
 
 const jsonTextDirect = <
   Base extends PostgresJsonExpression<any>,
@@ -217,11 +209,11 @@ const jsonTextDirect = <
   base: Base,
   target: Target & ExactJsonPathGuard<Target>
 ): JsonTextResultExpression<Base, Target> =>
-  postgresQuery.json.text(base as never, target as never) as unknown as JsonTextResultExpression<Base, Target>
+  postgresJson.text(base as never, target as never) as unknown as JsonTextResultExpression<Base, Target>
 
 const json = {
-  key: postgresQuery.json.key,
-  index: postgresQuery.json.index,
+  key: postgresJson.key,
+  index: postgresJson.index,
   path: exactPath,
   get: ((...args: [PostgresJsonExpression<any>, ExactJsonPathInput] | [ExactJsonPathInput]) =>
     args.length === 1
@@ -238,14 +230,14 @@ const json = {
   >(
     base: Base,
     target: Target & ExactJsonPathGuard<Target> & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.access">
-  ) => postgresQuery.json.access(base, target),
+  ) => postgresJson.access(base, target),
   traverse: <
     Base extends PostgresJsonExpression<any>,
     Target extends ExactJsonPathInput
   >(
     base: Base,
     target: Target & ExactJsonPathGuard<Target> & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.traverse">
-  ) => postgresQuery.json.traverse(base, target),
+  ) => postgresJson.traverse(base, target),
   text: ((...args: [PostgresJsonExpression<any>, ExactJsonPathInput] | [ExactJsonPathInput]) =>
     args.length === 1
       ? ((base: PostgresJsonExpression<any>) => jsonTextDirect(base as never, args[0] as never))
@@ -261,21 +253,21 @@ const json = {
   >(
     base: Base,
     target: Target & ExactJsonPathGuard<Target> & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.accessText">
-  ) => postgresQuery.json.accessText(base, target),
+  ) => postgresJson.accessText(base, target),
   traverseText: <
     Base extends PostgresJsonExpression<any>,
     Target extends ExactJsonPathInput
   >(
     base: Base,
     target: Target & ExactJsonPathGuard<Target> & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.traverseText">
-  ) => postgresQuery.json.traverseText(base, target),
-  buildObject: postgresQuery.json.buildObject,
-  buildArray: postgresQuery.json.buildArray,
-  toJson: postgresQuery.json.toJson,
-  typeOf: postgresQuery.json.typeOf,
-  length: postgresQuery.json.length,
-  keys: postgresQuery.json.keys,
-  stripNulls: postgresQuery.json.stripNulls,
+  ) => postgresJson.traverseText(base, target),
+  buildObject: postgresJson.buildObject,
+  buildArray: postgresJson.buildArray,
+  toJson: postgresJson.toJson,
+  typeOf: postgresJson.typeOf,
+  length: postgresJson.length,
+  keys: postgresJson.keys,
+  stripNulls: postgresJson.stripNulls,
   delete: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
@@ -285,7 +277,7 @@ const json = {
   ): JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">,
     Expression.DbTypeOf<Base>
-  > => postgresQuery.json.delete(base as any, target as any) as unknown as JsonResultExpression<
+  > => postgresJson.delete(base as any, target as any) as unknown as JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">,
     Expression.DbTypeOf<Base>
   >,
@@ -298,103 +290,103 @@ const json = {
   ): JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">,
     Expression.DbTypeOf<Base>
-  > => postgresQuery.json.remove(base as any, target as any) as unknown as JsonResultExpression<
+  > => postgresJson.remove(base as any, target as any) as unknown as JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">,
     Expression.DbTypeOf<Base>
   >
 }
 
 const jsonb = {
-  key: postgresQuery.jsonb.key,
-  index: postgresQuery.jsonb.index,
-  wildcard: postgresQuery.jsonb.wildcard,
-  slice: postgresQuery.jsonb.slice,
-  descend: postgresQuery.jsonb.descend,
-  path: postgresQuery.jsonb.path,
+  key: postgresJsonb.key,
+  index: postgresJsonb.index,
+  wildcard: postgresJsonb.wildcard,
+  slice: postgresJsonb.slice,
+  descend: postgresJsonb.descend,
+  path: postgresJsonb.path,
   get: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.get">,
     target: Target & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.get">
-  ) => postgresQuery.jsonb.get(base as Base, target),
+  ) => postgresJsonb.get(base as Base, target),
   access: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.access">,
     target: Target & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.access">
-  ) => postgresQuery.jsonb.access(base as Base, target),
+  ) => postgresJsonb.access(base as Base, target),
   traverse: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.traverse">,
     target: Target & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.traverse">
-  ) => postgresQuery.jsonb.traverse(base as Base, target),
+  ) => postgresJsonb.traverse(base as Base, target),
   text: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.text">,
     target: Target & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.text">
-  ) => postgresQuery.jsonb.text(base as Base, target),
+  ) => postgresJsonb.text(base as Base, target),
   accessText: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.accessText">,
     target: Target & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.accessText">
-  ) => postgresQuery.jsonb.accessText(base as Base, target),
+  ) => postgresJsonb.accessText(base as Base, target),
   traverseText: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.traverseText">,
     target: Target & JsonValuePathGuard<Expression.RuntimeOf<Base>, Target, "json.traverseText">
-  ) => postgresQuery.jsonb.traverseText(base as Base, target),
+  ) => postgresJsonb.traverseText(base as Base, target),
   contains: <
     Left extends PostgresJsonExpression<any>,
-    Right extends Parameters<typeof postgresQuery.jsonb.contains>[1]
+    Right extends Parameters<typeof postgresJsonb.contains>[1]
   >(
     left: Left & JsonbBaseGuard<Left, "jsonb.contains">,
     right: Right
-  ) => postgresQuery.jsonb.contains(left as Left, right),
+  ) => postgresJsonb.contains(left as Left, right),
   containedBy: <
     Left extends PostgresJsonExpression<any>,
-    Right extends Parameters<typeof postgresQuery.jsonb.containedBy>[1]
+    Right extends Parameters<typeof postgresJsonb.containedBy>[1]
   >(
     left: Left & JsonbBaseGuard<Left, "jsonb.containedBy">,
     right: Right
-  ) => postgresQuery.jsonb.containedBy(left as Left, right),
+  ) => postgresJsonb.containedBy(left as Left, right),
   hasKey: <
     Base extends PostgresJsonExpression<any>,
     Key extends string
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.hasKey">,
     key: Key
-  ) => postgresQuery.jsonb.hasKey(base as Base, key),
+  ) => postgresJsonb.hasKey(base as Base, key),
   keyExists: <
     Base extends PostgresJsonExpression<any>,
     Key extends string
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.keyExists">,
     key: Key
-  ) => postgresQuery.jsonb.keyExists(base as Base, key),
+  ) => postgresJsonb.keyExists(base as Base, key),
   hasAnyKeys: <
     Base extends PostgresJsonExpression<any>,
     Keys extends readonly [string, ...string[]]
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.hasAnyKeys">,
     ...keys: Keys
-  ) => postgresQuery.jsonb.hasAnyKeys(base as Base, ...keys),
+  ) => postgresJsonb.hasAnyKeys(base as Base, ...keys),
   hasAllKeys: <
     Base extends PostgresJsonExpression<any>,
     Keys extends readonly [string, ...string[]]
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.hasAllKeys">,
     ...keys: Keys
-  ) => postgresQuery.jsonb.hasAllKeys(base as Base, ...keys),
+  ) => postgresJsonb.hasAllKeys(base as Base, ...keys),
   delete: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>
@@ -404,7 +396,7 @@ const jsonb = {
   ): JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">,
     Expression.DbTypeOf<Base>
-  > => postgresQuery.jsonb.delete(base as any, target as any) as unknown as JsonResultExpression<
+  > => postgresJsonb.delete(base as any, target as any) as unknown as JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">,
     Expression.DbTypeOf<Base>
   >,
@@ -417,30 +409,30 @@ const jsonb = {
   ): JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">,
     Expression.DbTypeOf<Base>
-  > => postgresQuery.jsonb.remove(base as any, target as any) as unknown as JsonResultExpression<
+  > => postgresJsonb.remove(base as any, target as any) as unknown as JsonResultExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">,
     Expression.DbTypeOf<Base>
   >,
   set: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>,
-    Next extends Parameters<typeof postgresQuery.jsonb.set>[2]
+    Next extends Parameters<typeof postgresJsonb.set>[2]
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.set">,
     target: Target & JsonSetPathGuard<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
     next: Next,
-    options?: Parameters<typeof postgresQuery.jsonb.set>[3]
+    options?: Parameters<typeof postgresJsonb.set>[3]
   ): JsonResultExpression<
     JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
     Expression.DbTypeOf<Base>
-  > => postgresQuery.jsonb.set(base as any, target as any, next, options) as unknown as JsonResultExpression<
+  > => postgresJsonb.set(base as any, target as any, next, options) as unknown as JsonResultExpression<
     JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
     Expression.DbTypeOf<Base>
   >,
   insert: <
     Base extends PostgresJsonExpression<any>,
     Target extends JsonPath.CanonicalSegment | JsonPath.Path<any>,
-    Next extends Parameters<typeof postgresQuery.jsonb.insert>[2],
+    Next extends Parameters<typeof postgresJsonb.insert>[2],
     InsertAfter extends boolean = false
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.insert">,
@@ -452,47 +444,47 @@ const jsonb = {
   ): JsonResultExpression<
     JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">,
     Expression.DbTypeOf<Base>
-  > => postgresQuery.jsonb.insert(base as any, target as any, next, options) as unknown as JsonResultExpression<
+  > => postgresJsonb.insert(base as any, target as any, next, options) as unknown as JsonResultExpression<
     JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">,
     Expression.DbTypeOf<Base>
   >,
-  concat: postgresQuery.jsonb.concat,
-  merge: postgresQuery.jsonb.merge,
-  buildObject: postgresQuery.jsonb.buildObject,
-  buildArray: postgresQuery.jsonb.buildArray,
-  toJsonb: postgresQuery.jsonb.toJsonb,
+  concat: postgresJsonb.concat,
+  merge: postgresJsonb.merge,
+  buildObject: postgresJsonb.buildObject,
+  buildArray: postgresJsonb.buildArray,
+  toJsonb: postgresJsonb.toJsonb,
   typeOf: <
     Base extends PostgresJsonExpression<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.typeOf">
-  ) => postgresQuery.jsonb.typeOf(base as Base),
+  ) => postgresJsonb.typeOf(base as Base),
   length: <
     Base extends PostgresJsonExpression<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.length">
-  ) => postgresQuery.jsonb.length(base as Base),
+  ) => postgresJsonb.length(base as Base),
   keys: <
     Base extends PostgresJsonExpression<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.keys">
-  ) => postgresQuery.jsonb.keys(base as Base),
+  ) => postgresJsonb.keys(base as Base),
   stripNulls: <
     Base extends PostgresJsonExpression<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.stripNulls">
-  ) => postgresQuery.jsonb.stripNulls(base as Base),
+  ) => postgresJsonb.stripNulls(base as Base),
   pathExists: <
     Base extends PostgresJsonExpression<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.pathExists">,
-    query: Parameters<typeof postgresQuery.jsonb.pathExists>[1]
-  ) => postgresQuery.jsonb.pathExists(base as Base, query),
+    query: Parameters<typeof postgresJsonb.pathExists>[1]
+  ) => postgresJsonb.pathExists(base as Base, query),
   pathMatch: <
     Base extends PostgresJsonExpression<any>
   >(
     base: Base & JsonbBaseGuard<Base, "jsonb.pathMatch">,
-    query: Parameters<typeof postgresQuery.jsonb.pathMatch>[1]
-  ) => postgresQuery.jsonb.pathMatch(base as Base, query)
+    query: Parameters<typeof postgresJsonb.pathMatch>[1]
+  ) => postgresJsonb.pathMatch(base as Base, query)
 }
 
 /** Postgres shared JSON helpers for exact paths and functions that work on both json and jsonb. */

package/src/postgres/metadata.ts

@@ -10,7 +10,7 @@ export {
   type EnumModel,
   type SchemaModel,
   type TableModel
-} from "../internal/postgres-schema-model.js"
+} from "./internal/schema-model.js"
 
 export {
   EnumTypeId,
@@ -28,4 +28,4 @@ export type {
 export {
   normalizeDdlExpressionSql,
   renderDdlExpressionSql
-} from "../internal/schema-ddl.js"
+} from "./internal/schema-ddl.js"

package/src/postgres/query.ts

@@ -1,5 +1,7 @@
-import { postgresQuery } from "./private/query.js"
 import {
+  type AnyTableFunctionSource,
+  type AnyUnnestSource,
+  type AnyValuesSource,
   type CapabilitiesOfPlan,
   type CompletePlan,
   type DialectCompatiblePlan,
@@ -36,95 +38,117 @@ import {
   type StatementOfPlan,
   type StringExpressionInput
 } from "../internal/query.js"
+import {
+  type PublicNonStructuredFromApi,
+  type PublicGenerateSeriesApi,
+  type PublicStructuredFromConstraint,
+  type PublicStructuredFromResult,
+  type as postgresType,
+  values,
+  unnest,
+  select,
+  insert,
+  generateSeries as dslGenerateSeries,
+  from as dslFrom
+} from "./internal/dsl.js"
+
+export {
+  literal,
+  column,
+  eq,
+  neq,
+  lt,
+  lte,
+  gt,
+  gte,
+  isNull,
+  isNotNull,
+  like,
+  ilike,
+  collate,
+  regexMatch,
+  regexIMatch,
+  regexNotMatch,
+  regexNotIMatch,
+  and,
+  or,
+  not,
+  all,
+  any,
+  case_ as case,
+  match,
+  in_ as in,
+  notIn,
+  between,
+  contains,
+  containedBy,
+  overlaps,
+  exists,
+  isDistinctFrom,
+  isNotDistinctFrom,
+  excluded,
+  as,
+  with_ as with,
+  withRecursive,
+  lateral,
+  scalar,
+  inSubquery,
+  compareAny,
+  compareAll,
+  values,
+  unnest,
+  select,
+  returning,
+  onConflict,
+  insert,
+  update,
+  upsert,
+  delete_ as delete,
+  truncate,
+  merge,
+  transaction,
+  commit,
+  rollback,
+  savepoint,
+  rollbackTo,
+  releaseSavepoint,
+  createTable,
+  dropTable,
+  createIndex,
+  dropIndex,
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll,
+  where,
+  having,
+  innerJoin,
+  leftJoin,
+  rightJoin,
+  fullJoin,
+  crossJoin,
+  distinct,
+  distinctOn,
+  limit,
+  offset,
+  lock,
+  orderBy,
+  groupBy
+} from "./internal/dsl.js"
+export { postgresType as type }
+export const generateSeries: PublicGenerateSeriesApi = dslGenerateSeries as PublicGenerateSeriesApi
+
+type StructuredSource = AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource
+
+type StructuredFromApi = <CurrentSource extends StructuredSource>(
+  source: CurrentSource
+) => <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+  plan: PlanValue & PublicStructuredFromConstraint<PlanValue, CurrentSource, "postgres">
+) => PublicStructuredFromResult<PlanValue, CurrentSource, "postgres">
 
-export const literal = postgresQuery.literal
-export const column = postgresQuery.column
-export const eq = postgresQuery.eq
-export const neq = postgresQuery.neq
-export const lt = postgresQuery.lt
-export const lte = postgresQuery.lte
-export const gt = postgresQuery.gt
-export const gte = postgresQuery.gte
-export const isNull = postgresQuery.isNull
-export const isNotNull = postgresQuery.isNotNull
-export const like = postgresQuery.like
-export const ilike = postgresQuery.ilike
-export const regexMatch = postgresQuery.regexMatch
-export const regexIMatch = postgresQuery.regexIMatch
-export const regexNotMatch = postgresQuery.regexNotMatch
-export const regexNotIMatch = postgresQuery.regexNotIMatch
-export const and = postgresQuery.and
-export const or = postgresQuery.or
-export const not = postgresQuery.not
-export const all = postgresQuery.all
-export const any = postgresQuery.any
-const case_ = postgresQuery.case
-export const match = postgresQuery.match
-export const in_ = postgresQuery.in
-export const notIn = postgresQuery.notIn
-export const between = postgresQuery.between
-export const contains = postgresQuery.contains
-export const containedBy = postgresQuery.containedBy
-export const overlaps = postgresQuery.overlaps
-export const exists = postgresQuery.exists
-export const isDistinctFrom = postgresQuery.isDistinctFrom
-export const isNotDistinctFrom = postgresQuery.isNotDistinctFrom
-export const excluded = postgresQuery.excluded
-export const as = postgresQuery.as
-export const with_ = postgresQuery.with
-export const withRecursive = postgresQuery.withRecursive
-export const lateral = postgresQuery.lateral
-export const scalar = postgresQuery.scalar
-export const inSubquery = postgresQuery.inSubquery
-export const compareAny = postgresQuery.compareAny
-export const compareAll = postgresQuery.compareAll
-export const values = postgresQuery.values
-export const unnest = postgresQuery.unnest
-export const generateSeries = postgresQuery.generateSeries
-export const returning = postgresQuery.returning
-export const onConflict = postgresQuery.onConflict
-export const insert = postgresQuery.insert
-export const update = postgresQuery.update
-export const upsert = postgresQuery.upsert
-export const delete_ = postgresQuery.delete
-export const truncate = postgresQuery.truncate
-export const merge = postgresQuery.merge
-export const transaction = postgresQuery.transaction
-export const commit = postgresQuery.commit
-export const rollback = postgresQuery.rollback
-export const savepoint = postgresQuery.savepoint
-export const rollbackTo = postgresQuery.rollbackTo
-export const releaseSavepoint = postgresQuery.releaseSavepoint
-export const createTable = postgresQuery.createTable
-export const dropTable = postgresQuery.dropTable
-export const createIndex = postgresQuery.createIndex
-export const dropIndex = postgresQuery.dropIndex
-export const union = postgresQuery.union
-export const unionAll = postgresQuery.unionAll
-export const intersect = postgresQuery.intersect
-export const intersectAll = postgresQuery.intersectAll
-export const except = postgresQuery.except
-export const exceptAll = postgresQuery.exceptAll
-export const select = postgresQuery.select
-export const where = postgresQuery.where
-export const having = postgresQuery.having
-export const from = postgresQuery.from
-export const innerJoin = postgresQuery.innerJoin
-export const leftJoin = postgresQuery.leftJoin
-export const rightJoin = postgresQuery.rightJoin
-export const fullJoin = postgresQuery.fullJoin
-export const crossJoin = postgresQuery.crossJoin
-export const distinct = postgresQuery.distinct
-export const distinctOn = postgresQuery.distinctOn
-export const limit = postgresQuery.limit
-export const offset = postgresQuery.offset
-export const lock = postgresQuery.lock
-export const orderBy = postgresQuery.orderBy
-export const groupBy = postgresQuery.groupBy
-export { case_ as case }
-export { in_ as in }
-export { with_ as with }
-export { delete_ as delete }
+export const from: StructuredFromApi & PublicNonStructuredFromApi = dslFrom as StructuredFromApi & PublicNonStructuredFromApi
 
 export type {
   CapabilitiesOfPlan,

package/src/postgres/renderer.ts

@@ -1,4 +1,5 @@
 import * as CoreRenderer from "../internal/renderer.js"
+import { renderPostgresPlan } from "./internal/renderer.js"
 
 /** Postgres-specialized rendered query shape. */
 export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "postgres">
@@ -11,19 +12,8 @@ export { TypeId } from "../internal/renderer.js"
 export type { Projection } from "../internal/renderer.js"
 
 /** Creates the built-in Postgres renderer. */
-export function make(): Renderer
-export function make(dialect: "postgres"): Renderer
-export function make(
-  dialect: "postgres",
-  render: Parameters<typeof CoreRenderer.make>[1]
-): Renderer
-export function make(
-  dialectOrRender?: "postgres" | Parameters<typeof CoreRenderer.make>[1],
-  render?: Parameters<typeof CoreRenderer.make>[1]
-): Renderer {
-  const customRender = typeof dialectOrRender === "function" ? dialectOrRender : render
-  return customRender ? CoreRenderer.make("postgres", customRender as any) : CoreRenderer.make("postgres")
-}
+export const make = (): Renderer =>
+  CoreRenderer.make("postgres", renderPostgresPlan)
 
 /** Shared built-in Postgres renderer instance. */
 export const postgres = make()