npm - effect-qb - Versions diffs - 0.12.3 - Mend

effect-qb 0.12.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

package/README.md +1294 -0
package/dist/mysql.js +57575 -0
package/dist/postgres.js +6303 -0
package/package.json +42 -0
package/src/internal/aggregation-validation.ts +57 -0
package/src/internal/case-analysis.ts +50 -0
package/src/internal/coercion-analysis.ts +30 -0
package/src/internal/coercion-errors.ts +29 -0
package/src/internal/coercion-kind.ts +32 -0
package/src/internal/coercion-normalize.ts +7 -0
package/src/internal/coercion-rules.ts +25 -0
package/src/internal/column-state.ts +453 -0
package/src/internal/column.ts +417 -0
package/src/internal/datatypes/define.ts +44 -0
package/src/internal/datatypes/lookup.ts +280 -0
package/src/internal/datatypes/shape.ts +72 -0
package/src/internal/derived-table.ts +149 -0
package/src/internal/dialect.ts +30 -0
package/src/internal/executor.ts +390 -0
package/src/internal/expression-ast.ts +349 -0
package/src/internal/expression.ts +325 -0
package/src/internal/grouping-key.ts +82 -0
package/src/internal/json/ast.ts +63 -0
package/src/internal/json/errors.ts +13 -0
package/src/internal/json/path.ts +227 -0
package/src/internal/json/shape.ts +1 -0
package/src/internal/json/types.ts +386 -0
package/src/internal/mysql-dialect.ts +39 -0
package/src/internal/mysql-renderer.ts +37 -0
package/src/internal/plan.ts +64 -0
package/src/internal/postgres-dialect.ts +34 -0
package/src/internal/postgres-renderer.ts +40 -0
package/src/internal/predicate-analysis.ts +71 -0
package/src/internal/predicate-atom.ts +43 -0
package/src/internal/predicate-branches.ts +40 -0
package/src/internal/predicate-context.ts +279 -0
package/src/internal/predicate-formula.ts +100 -0
package/src/internal/predicate-key.ts +28 -0
package/src/internal/predicate-nnf.ts +12 -0
package/src/internal/predicate-normalize.ts +202 -0
package/src/internal/projection-alias.ts +15 -0
package/src/internal/projections.ts +101 -0
package/src/internal/query-ast.ts +297 -0
package/src/internal/query-factory.ts +6757 -0
package/src/internal/query-requirements.ts +40 -0
package/src/internal/query.ts +1590 -0
package/src/internal/renderer.ts +102 -0
package/src/internal/runtime-normalize.ts +344 -0
package/src/internal/runtime-schema.ts +428 -0
package/src/internal/runtime-value.ts +85 -0
package/src/internal/schema-derivation.ts +131 -0
package/src/internal/sql-expression-renderer.ts +1353 -0
package/src/internal/table-options.ts +225 -0
package/src/internal/table.ts +674 -0
package/src/mysql/column.ts +30 -0
package/src/mysql/datatypes/index.ts +6 -0
package/src/mysql/datatypes/spec.ts +180 -0
package/src/mysql/errors/catalog.ts +51662 -0
package/src/mysql/errors/fields.ts +21 -0
package/src/mysql/errors/index.ts +18 -0
package/src/mysql/errors/normalize.ts +232 -0
package/src/mysql/errors/requirements.ts +73 -0
package/src/mysql/executor.ts +134 -0
package/src/mysql/query.ts +189 -0
package/src/mysql/renderer.ts +19 -0
package/src/mysql/table.ts +157 -0
package/src/mysql.ts +18 -0
package/src/postgres/column.ts +20 -0
package/src/postgres/datatypes/index.ts +8 -0
package/src/postgres/datatypes/spec.ts +264 -0
package/src/postgres/errors/catalog.ts +452 -0
package/src/postgres/errors/fields.ts +48 -0
package/src/postgres/errors/index.ts +4 -0
package/src/postgres/errors/normalize.ts +209 -0
package/src/postgres/errors/requirements.ts +65 -0
package/src/postgres/errors/types.ts +38 -0
package/src/postgres/executor.ts +131 -0
package/src/postgres/query.ts +189 -0
package/src/postgres/renderer.ts +29 -0
package/src/postgres/table.ts +157 -0
package/src/postgres.ts +18 -0

package/src/internal/json/types.ts ADDED Viewed

@@ -0,0 +1,386 @@
+import type * as JsonPath from "./path.js"
+import type { JsonPathUsageError } from "./errors.js"
+export type JsonPrimitive = string | number | boolean | null
+export type JsonValue =
+  | JsonPrimitive
+  | readonly JsonValue[]
+  | { readonly [key: string]: JsonValue }
+type OptionalKeyOf<ObjectType extends object, Key extends PropertyKey> =
+  Key extends keyof ObjectType
+    ? {} extends Pick<ObjectType, Key> ? true : false
+    : true
+type NormalizeJsonTuple<Values extends readonly unknown[]> =
+  Values extends readonly []
+    ? readonly []
+    : Values extends readonly [infer Head, ...infer Tail]
+      ? readonly [NormalizeJsonLiteral<Head>, ...NormalizeJsonTuple<Tail>]
+      : readonly NormalizeJsonLiteral<Values[number]>[]
+type NormalizeJsonObject<ObjectType extends object> = {
+  readonly [Key in keyof ObjectType as Key extends string ? Key : never]:
+    NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>>
+}
+export type NormalizeJsonLiteral<Value> =
+  [Value] extends [never] ? never :
+    Value extends JsonPrimitive ? Value :
+      Value extends undefined | bigint | symbol | Date | ((...args: readonly any[]) => any) ? never :
+        Value extends readonly unknown[] ? NormalizeJsonTuple<Value> :
+          Value extends object ? NormalizeJsonObject<Value> :
+            never
+export type JsonLiteralInput = JsonPrimitive | readonly JsonLiteralInput[] | {
+  readonly [key: string]: JsonLiteralInput
+}
+type StripNull<Value> = Exclude<Value, null>
+type KeyStep<
+  Root,
+  Key extends string,
+  Operation extends string
+> = Root extends readonly unknown[]
+  ? JsonPathUsageError<Operation, Root, JsonPath.KeySegment<Key>, "key segments cannot be applied to arrays">
+  : Root extends object
+    ? Key extends keyof Root
+      ? NormalizeJsonLiteral<Exclude<Root[Key], undefined>> | (OptionalKeyOf<Root, Key> extends true ? null : never)
+      : Root extends Record<string, infer Value>
+        ? NormalizeJsonLiteral<Value> | null
+        : null
+    : JsonPathUsageError<Operation, Root, JsonPath.KeySegment<Key>, "key segments require an object-like json value">
+type TupleIndex<
+  Values extends readonly unknown[],
+  Index extends number,
+  Count extends readonly unknown[] = []
+> = Values extends readonly [infer Head, ...infer Tail]
+  ? Count["length"] extends Index
+    ? Head
+    : TupleIndex<Tail, Index, [...Count, unknown]>
+  : never
+type DropTupleIndex<
+  Values extends readonly unknown[],
+  Index extends number,
+  Count extends readonly unknown[] = []
+> = Values extends readonly [infer Head, ...infer Tail]
+  ? Count["length"] extends Index
+    ? readonly [...Tail]
+    : readonly [Head, ...DropTupleIndex<Tail, Index, [...Count, unknown]>]
+  : readonly []
+type SetTupleIndex<
+  Values extends readonly unknown[],
+  Index extends number,
+  Next,
+  Count extends readonly unknown[] = []
+> = Values extends readonly [infer Head, ...infer Tail]
+  ? Count["length"] extends Index
+    ? readonly [Next, ...Tail]
+    : readonly [Head, ...SetTupleIndex<Tail, Index, Next, [...Count, unknown]>]
+  : readonly NormalizeJsonLiteral<Next>[]
+type InsertTupleIndex<
+  Values extends readonly unknown[],
+  Index extends number,
+  Next,
+  After extends boolean,
+  Count extends readonly unknown[] = []
+> = Values extends readonly [infer Head, ...infer Tail]
+  ? Count["length"] extends Index
+    ? After extends true
+      ? readonly [Head, NormalizeJsonLiteral<Next>, ...Tail]
+      : readonly [NormalizeJsonLiteral<Next>, Head, ...Tail]
+    : readonly [Head, ...InsertTupleIndex<Tail, Index, Next, After, [...Count, unknown]>]
+  : readonly NormalizeJsonLiteral<Next>[]
+type IndexStep<
+  Root,
+  Index extends number,
+  Operation extends string
+> = Root extends readonly unknown[]
+  ? number extends Root["length"]
+    ? NormalizeJsonLiteral<Root[number]> | null
+    : NormalizeJsonLiteral<TupleIndex<Root, Index>> | (TupleIndex<Root, Index> extends never ? null : never)
+  : JsonPathUsageError<Operation, Root, JsonPath.IndexSegment<Index>, "index segments require an array-like json value">
+type NonExactStep<
+  Root,
+  Segment extends JsonPath.CanonicalSegment
+> = Segment extends JsonPath.WildcardSegment
+  ? NormalizeJsonLiteral<Root> | null
+  : Segment extends JsonPath.SliceSegment<any, any>
+    ? NormalizeJsonLiteral<Root> | null
+    : Segment extends JsonPath.DescendSegment
+      ? NormalizeJsonLiteral<Root> | null
+      : never
+type StepValue<
+  Root,
+  Segment extends JsonPath.CanonicalSegment,
+  Operation extends string
+> = Segment extends JsonPath.KeySegment<infer Key extends string>
+  ? KeyStep<Root, Key, Operation>
+  : Segment extends JsonPath.IndexSegment<infer Index extends number>
+    ? IndexStep<Root, Index, Operation>
+    : NonExactStep<Root, Segment>
+type StepSet<
+  Root,
+  Segment extends JsonPath.CanonicalSegment,
+  Next,
+  Operation extends string
+> = Segment extends JsonPath.KeySegment<infer Key extends string>
+  ? Root extends readonly unknown[]
+    ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot update arrays">
+    : Root extends object
+      ? Omit<Root, Key> & {
+          readonly [K in Key]: NormalizeJsonLiteral<Next>
+        }
+      : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value">
+  : Segment extends JsonPath.IndexSegment<infer Index extends number>
+    ? Root extends readonly unknown[]
+      ? number extends Root["length"]
+        ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[]
+        : SetTupleIndex<Root, Index, Next>
+      : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value">
+    : NormalizeJsonLiteral<Root>
+type StepDelete<
+  Root,
+  Segment extends JsonPath.CanonicalSegment,
+  Operation extends string
+> = Segment extends JsonPath.KeySegment<infer Key extends string>
+  ? Root extends readonly unknown[]
+    ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot delete from arrays">
+    : Root extends object
+      ? Omit<Root, Key>
+      : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value">
+  : Segment extends JsonPath.IndexSegment<infer Index extends number>
+    ? Root extends readonly unknown[]
+      ? number extends Root["length"]
+        ? Root
+        : DropTupleIndex<Root, Index>
+      : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value">
+    : NormalizeJsonLiteral<Root>
+type StepInsert<
+  Root,
+  Segment extends JsonPath.CanonicalSegment,
+  Next,
+  After extends boolean,
+  Operation extends string
+> = Segment extends JsonPath.IndexSegment<infer Index extends number>
+  ? Root extends readonly unknown[]
+    ? number extends Root["length"]
+      ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[]
+      : InsertTupleIndex<Root, Index, Next, After>
+    : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value">
+  : Segment extends JsonPath.KeySegment<infer Key extends string>
+    ? Root extends readonly unknown[]
+      ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot insert into arrays">
+      : Root extends object
+        ? Key extends keyof Root
+          ? Root
+          : Root & {
+              readonly [K in Key]: NormalizeJsonLiteral<Next>
+            }
+        : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value">
+    : NormalizeJsonLiteral<Root>
+type RecurseValue<
+  Current,
+  Segments extends readonly JsonPath.CanonicalSegment[],
+  Operation extends string
+> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]]
+  ? StepValue<Current, Head, Operation> extends infer Next
+    ? Next extends JsonPathUsageError<any, any, any, any>
+      ? Next
+      : Tail extends readonly []
+        ? Next
+        : null extends Next
+          ? RecurseValue<StripNull<Next>, Tail, Operation> | null
+          : RecurseValue<Next, Tail, Operation>
+    : never
+  : NormalizeJsonLiteral<Current>
+type RecurseSet<
+  Current,
+  Segments extends readonly JsonPath.CanonicalSegment[],
+  Next,
+  Operation extends string
+> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]]
+  ? Tail extends readonly []
+    ? StepSet<Current, Head, Next, Operation>
+    : StepValue<Current, Head, Operation> extends infer Child
+      ? Child extends JsonPathUsageError<any, any, any, any>
+        ? Child
+        : StepSet<
+            Current,
+            Head,
+            RecurseSet<StripNull<Child>, Tail, Next, Operation>,
+            Operation
+          >
+      : never
+  : NormalizeJsonLiteral<Next>
+type RecurseDelete<
+  Current,
+  Segments extends readonly JsonPath.CanonicalSegment[],
+  Operation extends string
+> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]]
+  ? Tail extends readonly []
+    ? StepDelete<Current, Head, Operation>
+    : StepValue<Current, Head, Operation> extends infer Child
+      ? Child extends JsonPathUsageError<any, any, any, any>
+        ? Child
+        : StepSet<
+            Current,
+            Head,
+            RecurseDelete<StripNull<Child>, Tail, Operation>,
+            Operation
+          >
+      : never
+  : NormalizeJsonLiteral<Current>
+type RecurseInsert<
+  Current,
+  Segments extends readonly JsonPath.CanonicalSegment[],
+  Next,
+  After extends boolean,
+  Operation extends string
+> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]]
+  ? Tail extends readonly []
+    ? StepInsert<Current, Head, Next, After, Operation>
+    : StepValue<Current, Head, Operation> extends infer Child
+      ? Child extends JsonPathUsageError<any, any, any, any>
+        ? Child
+        : StepSet<
+            Current,
+            Head,
+            RecurseInsert<StripNull<Child>, Tail, Next, After, Operation>,
+            Operation
+          >
+      : never
+  : NormalizeJsonLiteral<Current>
+export type JsonValueAtPath<
+  Root,
+  PathValue extends JsonPath.Path<any>,
+  Operation extends string = "json.get"
+> = RecurseValue<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Operation>
+export type JsonSetAtPath<
+  Root,
+  PathValue extends JsonPath.Path<any>,
+  Next,
+  Operation extends string = "json.set"
+> = RecurseSet<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Next, Operation>
+export type JsonInsertAtPath<
+  Root,
+  PathValue extends JsonPath.Path<any>,
+  Next,
+  After extends boolean = false,
+  Operation extends string = "json.insert"
+> = RecurseInsert<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Next, After, Operation>
+export type JsonDeleteAtPath<
+  Root,
+  PathValue extends JsonPath.Path<any>,
+  Operation extends string = "json.delete"
+> = RecurseDelete<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Operation>
+type ArrayElement<Value> = Value extends readonly (infer Element)[] ? Element : never
+type MergeJsonObjects<
+  Left extends object,
+  Right extends object
+> = Omit<Left, keyof Right> & Right
+type StripNullsTuple<Values extends readonly unknown[]> =
+  Values extends readonly []
+    ? readonly []
+    : Values extends readonly [infer Head, ...infer Tail]
+      ? readonly [JsonStripNullsResult<Head>, ...StripNullsTuple<Tail>]
+      : readonly JsonStripNullsResult<Values[number]>[]
+type StripNullsObject<ObjectType extends object> = (
+  {
+    readonly [Key in keyof ObjectType as Key extends string
+      ? null extends NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>>
+        ? never
+        : Key
+      : never]-?: JsonStripNullsResult<Exclude<ObjectType[Key], null>>
+  } & {
+    readonly [Key in keyof ObjectType as Key extends string
+      ? null extends NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>>
+        ? Key
+        : never
+      : never]?: JsonStripNullsResult<Exclude<ObjectType[Key], null>>
+  }
+)
+export type JsonStripNullsResult<Value> =
+  Value extends null ? null :
+    Value extends readonly unknown[] ? StripNullsTuple<Value> :
+      Value extends object ? StripNullsObject<Value> :
+        Value
+export type JsonConcatResult<
+  Left,
+  Right
+> = NormalizeJsonLiteral<Left> extends infer NormalizedLeft
+  ? NormalizeJsonLiteral<Right> extends infer NormalizedRight
+    ? NormalizedLeft extends readonly unknown[]
+      ? NormalizedRight extends readonly unknown[]
+        ? number extends NormalizedLeft["length"] | NormalizedRight["length"]
+          ? readonly (ArrayElement<NormalizedLeft> | ArrayElement<NormalizedRight>)[]
+          : readonly [...NormalizedLeft, ...NormalizedRight]
+        : unknown
+      : NormalizedLeft extends object
+        ? NormalizedRight extends object
+          ? MergeJsonObjects<NormalizedLeft, NormalizedRight>
+          : unknown
+        : unknown
+    : never
+    : never
+export type JsonBuildObject<
+  Shape extends Record<string, unknown>
+> = {
+  readonly [K in keyof Shape]: NormalizeJsonLiteral<Shape[K]>
+}
+export type JsonBuildArray<
+  Values extends readonly unknown[]
+> = {
+  readonly [K in keyof Values]: NormalizeJsonLiteral<Values[K]>
+} & readonly unknown[]
+export type JsonTextResult<Value> = Value extends JsonPrimitive ? `${Value}` : string
+export type JsonTypeName<Value> =
+  NormalizeJsonLiteral<Value> extends null ? "null"
+    : NormalizeJsonLiteral<Value> extends string ? "string"
+      : NormalizeJsonLiteral<Value> extends number ? "number"
+        : NormalizeJsonLiteral<Value> extends boolean ? "boolean"
+          : NormalizeJsonLiteral<Value> extends readonly unknown[] ? "array"
+            : NormalizeJsonLiteral<Value> extends object ? "object"
+              : "unknown"
+export type JsonLengthResult<Value> =
+  NormalizeJsonLiteral<Value> extends readonly unknown[] ? number :
+    NormalizeJsonLiteral<Value> extends object ? number :
+      null
+export type JsonKeysResult<Value> =
+  NormalizeJsonLiteral<Value> extends object
+    ? NormalizeJsonLiteral<Value> extends readonly unknown[]
+      ? readonly []
+      : readonly Extract<keyof NormalizeJsonLiteral<Value>, string>[]
+    : null

package/src/internal/mysql-dialect.ts ADDED Viewed

@@ -0,0 +1,39 @@
+import type { RenderState, SqlDialect } from "./dialect.js"
+const quoteIdentifier = (value: string): string => `\`${value.replaceAll("`", "``")}\``
+const renderLiteral = (value: unknown, state: RenderState): string => {
+  if (value === null) {
+    return "null"
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false"
+  }
+  state.params.push(value)
+  return "?"
+}
+/**
+ * Internal runtime dialect sketch for MySQL.
+ *
+ * This is intentionally not wired into the public renderer surface yet. It
+ * exists to pressure-test the current abstraction seam and to document the
+ * concrete SQL differences we still need to account for as dialect support
+ * grows.
+ */
+export const mysqlDialect: SqlDialect<"mysql"> = {
+  name: "mysql",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName
+      ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
+      : quoteIdentifier(baseTableName)
+    return tableName === baseTableName
+      ? renderedBase
+      : `${renderedBase} as ${quoteIdentifier(tableName)}`
+  },
+  renderConcat(values) {
+    return `concat(${values.join(", ")})`
+  }
+}

package/src/internal/mysql-renderer.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import * as Query from "./query.js"
+import { type RenderState } from "./dialect.js"
+import { mysqlDialect } from "./mysql-dialect.js"
+import { type Projection } from "./projections.js"
+import { renderQueryAst } from "./sql-expression-renderer.js"
+/**
+ * Internal rendered-query payload produced by the built-in MySQL renderer.
+ */
+export interface MysqlRenderResult {
+  readonly sql: string
+  readonly params: readonly unknown[]
+  readonly projections: readonly Projection[]
+}
+/**
+ * Renders the current query AST into MySQL-shaped SQL plus bind parameters.
+ */
+export const renderMysqlPlan = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+  plan: Query.DialectCompatiblePlan<PlanValue, "mysql">
+): MysqlRenderResult => {
+  const state: RenderState = {
+    params: [],
+    ctes: [],
+    cteNames: new Set<string>()
+  }
+  const rendered = renderQueryAst(
+    Query.getAst(plan as Query.QueryPlan<any, any, any, any, any, any, any, any, any>) as any,
+    state,
+    mysqlDialect
+  )
+  return {
+    sql: rendered.sql,
+    params: state.params,
+    projections: rendered.projections
+  }
+}

package/src/internal/plan.ts ADDED Viewed

@@ -0,0 +1,64 @@
+import type { Pipeable } from "effect/Pipeable"
+/** Symbol used to attach logical-plan metadata to runtime values. */
+export const TypeId: unique symbol = Symbol.for("effect-qb/Plan")
+export type TypeId = typeof TypeId
+/**
+ * Source availability mode within a query scope.
+ *
+ * `required` means the source is guaranteed to produce a row at this point in
+ * the plan. `optional` means the source may be absent, such as the nullable
+ * side of a left join.
+ */
+export type SourceMode = "required" | "optional"
+/** Source made available to a plan. */
+export interface Source<Name extends string = string, Mode extends SourceMode = SourceMode> {
+  readonly name: Name
+  readonly mode: Mode
+  readonly baseName?: string
+}
+/**
+ * Canonical static metadata stored on a plan.
+ *
+ * `required` tracks sources that the selection references but which are not yet
+ * in scope. `available` tracks sources already in scope for subsequent query
+ * operations.
+ */
+export interface State<
+  Selection,
+  Required,
+  Available extends Record<string, Source>,
+  Dialect extends string
+> {
+  readonly selection: Selection
+  readonly required: Required
+  readonly available: Available
+  readonly dialect: Dialect
+}
+/**
+ * A composable logical query plan.
+ *
+ * Tables implement this interface as already-complete plans. Future query
+ * builders such as `select()` and `from()` should produce and transform values
+ * with this same structure.
+ */
+export interface Plan<
+  Selection,
+  Required = never,
+  Available extends Record<string, Source> = {},
+  Dialect extends string = never
+> extends Pipeable {
+  readonly [TypeId]: State<Selection, Required, Available, Dialect>
+}
+/** Convenience alias for any plan-like value. */
+export type Any = Plan<any, any, Record<string, Source>, string>
+/** Extracts a plan's selection shape. */
+export type SelectionOf<Value extends Any> = Value[typeof TypeId]["selection"]
+/** Extracts a plan's effective dialect. */
+export type DialectOf<Value extends Any> = Value[typeof TypeId]["dialect"]

package/src/internal/postgres-dialect.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import type { RenderState, SqlDialect } from "./dialect.js"
+const quoteIdentifier = (value: string): string => `"${value.replaceAll("\"", "\"\"")}"`
+const renderLiteral = (value: unknown, state: RenderState): string => {
+  if (value === null) {
+    return "null"
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false"
+  }
+  state.params.push(value)
+  return `$${state.params.length}`
+}
+/**
+ * Built-in runtime dialect implementation for Postgres.
+ */
+export const postgresDialect: SqlDialect<"postgres"> = {
+  name: "postgres",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName
+      ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
+      : quoteIdentifier(baseTableName)
+    return tableName === baseTableName
+      ? renderedBase
+      : `${renderedBase} as ${quoteIdentifier(tableName)}`
+  },
+  renderConcat(values) {
+    return `(${values.join(" || ")})`
+  }
+}

package/src/internal/postgres-renderer.ts ADDED Viewed

@@ -0,0 +1,40 @@
+import * as Query from "./query.js"
+import { type RenderState } from "./dialect.js"
+import { postgresDialect } from "./postgres-dialect.js"
+import { type Projection } from "./projections.js"
+import { renderQueryAst } from "./sql-expression-renderer.js"
+/**
+ * Minimal rendered-query payload produced by the built-in Postgres renderer.
+ *
+ * The public `Renderer` wrapper adds dialect branding and validates projection
+ * metadata before exposing the final `RenderedQuery`.
+ */
+export interface PostgresRenderResult {
+  readonly sql: string
+  readonly params: readonly unknown[]
+  readonly projections: readonly Projection[]
+}
+/**
+ * Renders the current query AST into Postgres SQL plus bind parameters.
+ */
+export const renderPostgresPlan = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+  plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
+): PostgresRenderResult => {
+  const state: RenderState = {
+    params: [],
+    ctes: [],
+    cteNames: new Set<string>()
+  }
+  const rendered = renderQueryAst(
+    Query.getAst(plan as Query.QueryPlan<any, any, any, any, any, any, any, any, any>) as any,
+    state,
+    postgresDialect
+  )
+  return {
+    sql: rendered.sql,
+    params: state.params,
+    projections: rendered.projections
+  }
+}

package/src/internal/predicate-analysis.ts ADDED Viewed

@@ -0,0 +1,71 @@
+import type { AnalyzeFormula } from "./predicate-context.js"
+import type { FormulaOfPredicate } from "./predicate-normalize.js"
+import type { And, Not, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+type ContextOf<Formula extends PredicateFormula> = AnalyzeFormula<Formula>
+export type GuaranteedNonNullKeys<
+  Assumptions extends PredicateFormula
+> = ContextOf<Assumptions>["nonNullKeys"]
+export type GuaranteedNullKeys<
+  Assumptions extends PredicateFormula
+> = ContextOf<Assumptions>["nullKeys"]
+export type GuaranteedSourceNames<
+  Assumptions extends PredicateFormula
+> = ContextOf<Assumptions>["sourceNames"]
+export type GuaranteedEqLiteral<
+  Assumptions extends PredicateFormula,
+  Key extends string
+> = Key extends keyof ContextOf<Assumptions>["eqLiterals"]
+  ? ContextOf<Assumptions>["eqLiterals"][Key]
+  : never
+type IsContradiction<Formula extends PredicateFormula> =
+  ContextOf<Formula>["contradiction"] extends true ? true : false
+type ContradictoryAssumption<
+  Assumptions extends PredicateFormula,
+  Formula extends PredicateFormula
+> = IsContradiction<And<Assumptions, Formula>>
+type ContradictionFromNegation<
+  Assumptions extends PredicateFormula,
+  Formula extends PredicateFormula
+> = IsContradiction<And<Assumptions, Not<Formula>>>
+export type AssumeFormulaTrue<
+  Assumptions extends PredicateFormula,
+  Formula extends PredicateFormula
+> = Assumptions extends TrueFormula
+  ? Formula
+  : And<Assumptions, Formula>
+export type AssumeFormulaFalse<
+  Assumptions extends PredicateFormula,
+  Formula extends PredicateFormula
+> = Assumptions extends TrueFormula
+  ? Not<Formula>
+  : And<Assumptions, Not<Formula>>
+export type AssumeTrue<
+  Assumptions extends PredicateFormula,
+  Predicate
+> = AssumeFormulaTrue<Assumptions, FormulaOfPredicate<Predicate>>
+export type AssumeFalse<
+  Assumptions extends PredicateFormula,
+  Predicate
+> = AssumeFormulaFalse<Assumptions, FormulaOfPredicate<Predicate>>
+export type Contradicts<
+  Assumptions extends PredicateFormula,
+  Predicate
+> = ContradictoryAssumption<Assumptions, FormulaOfPredicate<Predicate>>
+export type Implies<
+  Assumptions extends PredicateFormula,
+  Predicate
+> = ContradictionFromNegation<Assumptions, FormulaOfPredicate<Predicate>>