effect-qb 0.12.3 → 0.14.0

package/src/internal/renderer.ts

@@ -41,12 +41,12 @@ export type RowOf<Value extends RenderedQuery<any, any>> = Value[typeof TypeId][
  */
 export interface Renderer<Dialect extends string = string> {
   readonly dialect: Dialect
-  render<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+  render<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ): RenderedQuery<any, Dialect>
 }
 
-type CustomRender<Dialect extends string> = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+type CustomRender<Dialect extends string> = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
   plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
 ) => {
   readonly sql: string

package/src/internal/runtime-schema.ts

@@ -5,6 +5,14 @@ import * as Expression from "./expression.js"
 import * as ExpressionAst from "./expression-ast.js"
 import * as Query from "./query.js"
 import * as JsonPath from "./json/path.js"
+import type { PredicateFormula } from "./predicate-formula.js"
+import {
+  assumeFormulaFalse,
+  assumeFormulaTrue,
+  contradictsFormula,
+  formulaOfExpression as formulaOfExpressionRuntime,
+  impliesFormula
+} from "./predicate-runtime.js"
 import { flattenSelection } from "./projections.js"
 import {
   BigIntStringSchema,
@@ -23,6 +31,10 @@ import type { RuntimeTag } from "./datatypes/shape.js"
 
 export type RuntimeSchema = Schema.Schema<any, any, any>
 
+type SchemaContext = {
+  readonly assumptions: PredicateFormula
+}
+
 const schemaCache = new WeakMap<Expression.Any, RuntimeSchema | undefined>()
 
 const stripParameterizedKind = (kind: string): string => {
@@ -284,18 +296,59 @@ const jsonCompatibleSchema = (schema: RuntimeSchema | undefined): RuntimeSchema
 }
 
 const buildStructSchema = (
-  entries: readonly { readonly key: string; readonly value: Expression.Any }[]
+  entries: readonly { readonly key: string; readonly value: Expression.Any }[],
+  context?: SchemaContext
 ): RuntimeSchema => {
   const fields = Object.fromEntries(
-    entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value) ?? JsonValueSchema])
+    entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema])
   )
   return Schema.Struct(fields as Record<string, RuntimeSchema>)
 }
 
-const buildTupleSchema = (values: readonly Expression.Any[]): RuntimeSchema =>
-  Schema.Tuple(...values.map((value) => expressionRuntimeSchema(value) ?? JsonValueSchema))
+const buildTupleSchema = (values: readonly Expression.Any[], context?: SchemaContext): RuntimeSchema =>
+  Schema.Tuple(...values.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema))
+
+const deriveCaseSchema = (
+  ast: ExpressionAst.CaseNode,
+  context?: SchemaContext
+): RuntimeSchema | undefined => {
+  if (context === undefined) {
+    return unionSchemas([
+      ...ast.branches.map((branch) => expressionRuntimeSchema(branch.then)),
+      expressionRuntimeSchema(ast.else)
+    ])
+  }
+
+  const schemas: RuntimeSchema[] = []
+  let elseAssumptions = context.assumptions
+
+  for (const branch of ast.branches) {
+    const whenFormula = formulaOfExpressionRuntime(branch.when)
+    if (contradictsFormula(elseAssumptions, whenFormula)) {
+      continue
+    }
+
+    const branchContext = { assumptions: assumeFormulaTrue(elseAssumptions, whenFormula) }
+    const branchSchema = expressionRuntimeSchema(branch.then, branchContext)
+    if (branchSchema !== undefined) {
+      schemas.push(branchSchema)
+    }
+
+    if (impliesFormula(elseAssumptions, whenFormula)) {
+      return unionSchemas(schemas)
+    }
+
+    elseAssumptions = assumeFormulaFalse(elseAssumptions, whenFormula)
+  }
+
+  const elseSchema = expressionRuntimeSchema(ast.else, { assumptions: elseAssumptions })
+  return unionSchemas(elseSchema === undefined ? schemas : [...schemas, elseSchema])
+}
 
-const deriveRuntimeSchema = (expression: Expression.Any): RuntimeSchema | undefined => {
+const deriveRuntimeSchema = (
+  expression: Expression.Any,
+  context?: SchemaContext
+): RuntimeSchema | undefined => {
   const state = expression[Expression.TypeId]
   if (state.runtimeSchema !== undefined) {
     return state.runtimeSchema
@@ -363,28 +416,25 @@ const deriveRuntimeSchema = (expression: Expression.Any): RuntimeSchema | undefi
       return Schema.Number
     case "max":
     case "min":
-      return expressionRuntimeSchema(ast.value)
+      return expressionRuntimeSchema(ast.value, context)
     case "case":
-      return unionSchemas([
-        ...ast.branches.map((branch) => expressionRuntimeSchema(branch.then)),
-        expressionRuntimeSchema(ast.else)
-      ])
+      return deriveCaseSchema(ast, context)
     case "coalesce":
-      return unionSchemas(ast.values.map(expressionRuntimeSchema))
+      return unionSchemas(ast.values.map((value) => expressionRuntimeSchema(value, context)))
     case "scalarSubquery":
       {
         const selection = firstSelectedExpression(ast.plan)
-        return selection === undefined ? undefined : expressionRuntimeSchema(selection)
+        return selection === undefined ? undefined : expressionRuntimeSchema(selection, context)
       }
     case "window":
       return ast.function === "over" && ast.value !== undefined
-        ? expressionRuntimeSchema(ast.value)
+        ? expressionRuntimeSchema(ast.value, context)
         : Schema.Number
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
     case "jsonTraverse": {
-      const baseSchema = expressionRuntimeSchema(ast.base!)
+      const baseSchema = expressionRuntimeSchema(ast.base!, context)
       const segments = ast.segments
       if (baseSchema === undefined || segments === undefined || !exactJsonSegments(segments)) {
         return JsonValueSchema
@@ -397,27 +447,31 @@ const deriveRuntimeSchema = (expression: Expression.Any): RuntimeSchema | undefi
     case "jsonRemove":
     case "jsonSet":
     case "jsonInsert":
-      return expressionRuntimeSchema(ast.base!)
+      return expressionRuntimeSchema(ast.base!, context)
     case "jsonStripNulls":
-      return expressionRuntimeSchema(ast.value!)
+      return expressionRuntimeSchema(ast.value!, context)
     case "jsonConcat":
     case "jsonMerge":
       return JsonValueSchema
     case "jsonBuildObject":
-      return buildStructSchema(ast.entries ?? [])
+      return buildStructSchema(ast.entries ?? [], context)
     case "jsonBuildArray":
-      return buildTupleSchema(ast.values ?? [])
+      return buildTupleSchema(ast.values ?? [], context)
     case "jsonToJson":
     case "jsonToJsonb":
-      return jsonCompatibleSchema(expressionRuntimeSchema(ast.value!))
+      return jsonCompatibleSchema(expressionRuntimeSchema(ast.value!, context))
     case "jsonKeys":
       return Schema.Array(Schema.String)
   }
 }
 
 export const expressionRuntimeSchema = (
-  expression: Expression.Any
+  expression: Expression.Any,
+  context?: SchemaContext
 ): RuntimeSchema | undefined => {
+  if (context !== undefined) {
+    return deriveRuntimeSchema(expression, context) ?? runtimeSchemaForDbType(expression[Expression.TypeId].dbType)
+  }
   const cached = schemaCache.get(expression)
   if (cached !== undefined || schemaCache.has(expression)) {
     return cached

package/src/internal/schema-ddl.ts

@@ -0,0 +1,55 @@
+import type * as Expression from "./expression.js"
+import type { RenderState, SqlDialect } from "./dialect.js"
+import { postgresDialect } from "./postgres-dialect.js"
+import * as SchemaExpression from "./schema-expression.js"
+import { renderExpression } from "./sql-expression-renderer.js"
+import type { DdlExpressionLike } from "./table-options.js"
+import { parse, toSql } from "pgsql-ast-parser"
+
+export const renderDdlExpression = (
+  expression: DdlExpressionLike,
+  state: RenderState,
+  dialect: SqlDialect
+): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression as Expression.Any, state, dialect)
+
+const escapeString = (value: string): string => `'${value.replaceAll("'", "''")}'`
+
+const inlineLiteralDialect: SqlDialect<"postgres"> = {
+  ...postgresDialect,
+  renderLiteral(value) {
+    if (value === null) {
+      return "null"
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false"
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+      return String(value)
+    }
+    if (value instanceof Date) {
+      return escapeString(value.toISOString())
+    }
+    return escapeString(String(value))
+  }
+}
+
+export const renderDdlExpressionSql = (expression: DdlExpressionLike): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression as Expression.Any, {
+        params: [],
+        ctes: [],
+        cteNames: new Set()
+      }, inlineLiteralDialect)
+
+export const normalizeDdlExpressionSql = (expression: DdlExpressionLike): string => {
+  const rendered = renderDdlExpressionSql(expression)
+  try {
+    return toSql.expr(parse(rendered, "expr"))
+  } catch {
+    return rendered.trim()
+  }
+}

package/src/internal/schema-derivation.ts

@@ -1,4 +1,5 @@
 import * as VariantSchema from "@effect/experimental/VariantSchema"
+import type * as Brand from "effect/Brand"
 import * as Schema from "effect/Schema"
 
 import {
@@ -43,43 +44,112 @@ type UpdateKeys<Fields extends TableFieldMap, PrimaryKey extends keyof Fields> =
 
 type Simplify<T> = { [K in keyof T]: T[K] } & {}
 
+type BrandedValue<
+  Value,
+  BrandName extends string
+> = [Extract<Value, null | undefined>] extends [never]
+  ? Value & Brand.Brand<BrandName>
+  : Exclude<Value, null | undefined> & Brand.Brand<BrandName> | Extract<Value, null | undefined>
+
+type BrandNameOf<
+  TableName extends string,
+  ColumnName extends string
+> = `${TableName}.${ColumnName}`
+
+type BrandedSelectType<
+  Column extends AnyColumnDefinition,
+  TableName extends string,
+  ColumnName extends string
+> = Column["metadata"]["brand"] extends true
+  ? BrandedValue<SelectType<Column>, BrandNameOf<TableName, ColumnName>>
+  : SelectType<Column>
+
+type BrandedInsertType<
+  Column extends AnyColumnDefinition,
+  TableName extends string,
+  ColumnName extends string
+> = Column["metadata"]["brand"] extends true
+  ? BrandedValue<InsertType<Column>, BrandNameOf<TableName, ColumnName>>
+  : InsertType<Column>
+
+type BrandedUpdateType<
+  Column extends AnyColumnDefinition,
+  TableName extends string,
+  ColumnName extends string
+> = Column["metadata"]["brand"] extends true
+  ? BrandedValue<UpdateType<Column>, BrandNameOf<TableName, ColumnName>>
+  : UpdateType<Column>
+
 /** Row shape returned by selecting from a table. */
-export type SelectRow<Fields extends TableFieldMap> = Simplify<{
-  [K in keyof Fields]: SelectType<Fields[K]>
+export type SelectRow<
+  TableName extends string,
+  Fields extends TableFieldMap
+> = Simplify<{
+  [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>
 }>
 
 /** Insert payload derived from a table field map. */
-export type InsertRow<Fields extends TableFieldMap> = Simplify<
-  { [K in RequiredInsertKeys<Fields>]: InsertType<Fields[K]> } &
-    { [K in OptionalInsertKeys<Fields>]?: InsertType<Fields[K]> }
+export type InsertRow<
+  TableName extends string,
+  Fields extends TableFieldMap
+> = Simplify<
+  { [K in RequiredInsertKeys<Fields>]: BrandedInsertType<Fields[K], TableName, Extract<K, string>> } &
+    { [K in OptionalInsertKeys<Fields>]?: BrandedInsertType<Fields[K], TableName, Extract<K, string>> }
 >
 
 /** Update payload derived from a table field map and primary key. */
-export type UpdateRow<Fields extends TableFieldMap, PrimaryKey extends keyof Fields> = Simplify<
+export type UpdateRow<
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKey extends keyof Fields
+> = Simplify<
   Partial<{
-    [K in UpdateKeys<Fields, PrimaryKey>]: UpdateType<Fields[K]>
+    [K in UpdateKeys<Fields, PrimaryKey>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>
   }>
 >
 
-const selectSchema = (column: AnyColumnDefinition): Schema.Schema.Any =>
-  column.metadata.nullable ? Schema.NullOr(column.schema) : column.schema
+const maybeBrandSchema = (
+  column: AnyColumnDefinition,
+  tableName: string,
+  columnName: string
+): Schema.Schema.Any =>
+  column.metadata.brand === true
+    ? Schema.brand(`${tableName}.${columnName}`)(column.schema)
+    : column.schema
+
+const selectSchema = (
+  column: AnyColumnDefinition,
+  tableName: string,
+  columnName: string
+): Schema.Schema.Any =>
+  column.metadata.nullable ? Schema.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName)
 
-const insertSchema = (column: AnyColumnDefinition): any | undefined => {
+const insertSchema = (
+  column: AnyColumnDefinition,
+  tableName: string,
+  columnName: string
+): any | undefined => {
   if (column.metadata.generated) {
     return undefined
   }
-  const base = column.metadata.nullable ? Schema.NullOr(column.schema) : column.schema
+  const base = column.metadata.nullable
+    ? Schema.NullOr(maybeBrandSchema(column, tableName, columnName))
+    : maybeBrandSchema(column, tableName, columnName)
   return column.metadata.nullable || column.metadata.hasDefault ? Schema.optional(base) : base
 }
 
 const updateSchema = (
   column: AnyColumnDefinition,
+  tableName: string,
+  columnName: string,
   isPrimaryKey: boolean
 ): any | undefined => {
   if (column.metadata.generated || isPrimaryKey) {
     return undefined
   }
-  const base = column.metadata.nullable ? Schema.NullOr(column.schema) : column.schema
+  const base = column.metadata.nullable
+    ? Schema.NullOr(maybeBrandSchema(column, tableName, columnName))
+    : maybeBrandSchema(column, tableName, columnName)
   return Schema.optional(base)
 }
 
@@ -90,26 +160,28 @@ const updateSchema = (
  * real runtime schemas.
  */
 export const deriveSchemas = <
+  TableName extends string,
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string
 >(
+  tableName: TableName,
   fields: Fields,
   primaryKeyColumns: readonly PrimaryKeyColumns[]
 ): {
-  readonly select: Schema.Schema<SelectRow<Fields>>
-  readonly insert: Schema.Schema<InsertRow<Fields>>
-  readonly update: Schema.Schema<UpdateRow<Fields, PrimaryKeyColumns>>
+  readonly select: Schema.Schema<SelectRow<TableName, Fields>>
+  readonly insert: Schema.Schema<InsertRow<TableName, Fields>>
+  readonly update: Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
 } => {
   const primaryKeySet = new Set<string>(primaryKeyColumns)
   const variants: Record<string, VariantSchema.Field<any>> = {}
   for (const [key, column] of Object.entries(fields)) {
     const config: Record<Variants, any> = {
-      select: selectSchema(column),
+      select: selectSchema(column, tableName, key),
       insert: undefined,
       update: undefined
     }
-    const insert = insertSchema(column)
-    const update = updateSchema(column, primaryKeySet.has(key))
+    const insert = insertSchema(column, tableName, key)
+    const update = updateSchema(column, tableName, key, primaryKeySet.has(key))
     if (insert !== undefined) {
       config.insert = insert
     } else {
@@ -124,8 +196,8 @@ export const deriveSchemas = <
   }
   const struct = TableSchema.Struct(variants as any)
   return {
-    select: TableSchema.extract(struct, "select") as unknown as Schema.Schema<SelectRow<Fields>>,
-    insert: TableSchema.extract(struct, "insert") as unknown as Schema.Schema<InsertRow<Fields>>,
-    update: TableSchema.extract(struct, "update") as unknown as Schema.Schema<UpdateRow<Fields, PrimaryKeyColumns>>
+    select: TableSchema.extract(struct, "select") as unknown as Schema.Schema<SelectRow<TableName, Fields>>,
+    insert: TableSchema.extract(struct, "insert") as unknown as Schema.Schema<InsertRow<TableName, Fields>>,
+    update: TableSchema.extract(struct, "update") as unknown as Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
   }
 }

package/src/internal/schema-expression.ts

@@ -0,0 +1,44 @@
+import { parse, toSql, type Expr } from "pgsql-ast-parser"
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
+export const TypeId: unique symbol = Symbol.for("effect-qb/SchemaExpression")
+
+export type TypeId = typeof TypeId
+
+const SchemaExpressionProto = {
+  pipe(this: unknown) {
+    return pipeArguments(this, arguments)
+  }
+}
+
+export interface SchemaExpression extends Pipeable {
+  readonly [TypeId]: {
+    readonly dialect: "postgres"
+    readonly ast: Expr
+  }
+}
+
+export type Any = SchemaExpression
+
+export const isSchemaExpression = (value: unknown): value is SchemaExpression =>
+  typeof value === "object" && value !== null && TypeId in value
+
+export const fromAst = (ast: Expr): SchemaExpression => {
+  const expression = Object.create(SchemaExpressionProto)
+  expression[TypeId] = {
+    dialect: "postgres",
+    ast
+  }
+  return expression
+}
+
+export const parseExpression = (sql: string): SchemaExpression =>
+  fromAst(parse(sql, "expr"))
+
+export const toAst = (expression: SchemaExpression): Expr => expression[TypeId].ast
+
+export const render = (expression: SchemaExpression): string =>
+  toSql.expr(expression[TypeId].ast)
+
+export const normalize = (expression: SchemaExpression): SchemaExpression =>
+  parseExpression(render(expression))