effect-qb 0.12.3

package/src/internal/runtime-schema.ts

@@ -0,0 +1,428 @@
+import * as Schema from "effect/Schema"
+import * as SchemaAST from "effect/SchemaAST"
+
+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 { flattenSelection } from "./projections.js"
+import {
+  BigIntStringSchema,
+  DecimalStringSchema,
+  InstantStringSchema,
+  JsonValueSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  OffsetTimeStringSchema,
+  YearStringSchema
+} from "./runtime-value.js"
+import { mysqlDatatypeKinds } from "../mysql/datatypes/spec.js"
+import { postgresDatatypeKinds } from "../postgres/datatypes/spec.js"
+import type { RuntimeTag } from "./datatypes/shape.js"
+
+export type RuntimeSchema = Schema.Schema<any, any, any>
+
+const schemaCache = new WeakMap<Expression.Any, RuntimeSchema | undefined>()
+
+const stripParameterizedKind = (kind: string): string => {
+  const openParen = kind.indexOf("(")
+  return openParen === -1 ? kind : kind.slice(0, openParen)
+}
+
+const stripArrayKind = (kind: string): string => {
+  let current = kind
+  while (current.endsWith("[]")) {
+    current = current.slice(0, -2)
+  }
+  return current
+}
+
+const baseKind = (kind: string): string => stripArrayKind(stripParameterizedKind(kind))
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const runtimeSchemaForTag = (tag: RuntimeTag): RuntimeSchema | undefined => {
+  switch (tag) {
+    case "string":
+      return Schema.String
+    case "number":
+      return Schema.Number
+    case "bigintString":
+      return BigIntStringSchema
+    case "boolean":
+      return Schema.Boolean
+    case "json":
+      return JsonValueSchema
+    case "localDate":
+      return LocalDateStringSchema
+    case "localTime":
+      return LocalTimeStringSchema
+    case "offsetTime":
+      return OffsetTimeStringSchema
+    case "localDateTime":
+      return LocalDateTimeStringSchema
+    case "instant":
+      return InstantStringSchema
+    case "year":
+      return YearStringSchema
+    case "decimalString":
+      return DecimalStringSchema
+    case "bytes":
+      return Schema.Uint8ArrayFromSelf
+    case "array":
+      return Schema.Array(Schema.Unknown)
+    case "record":
+      return Schema.Record({
+        key: Schema.String,
+        value: Schema.Unknown
+      })
+    case "null":
+      return Schema.Null
+    case "unknown":
+      return undefined
+  }
+}
+
+const runtimeTagOfBaseDbType = (
+  dialect: string,
+  kind: string
+): RuntimeTag | undefined => {
+  const normalizedKind = baseKind(kind)
+  if (dialect === "postgres") {
+    return postgresDatatypeKinds[normalizedKind as keyof typeof postgresDatatypeKinds]?.runtime
+  }
+  if (dialect === "mysql") {
+    return mysqlDatatypeKinds[normalizedKind as keyof typeof mysqlDatatypeKinds]?.runtime
+  }
+  return undefined
+}
+
+export const runtimeSchemaForDbType = (
+  dbType: Expression.DbType.Any
+): RuntimeSchema | undefined => {
+  if ("base" in dbType) {
+    return runtimeSchemaForDbType(dbType.base)
+  }
+  if ("element" in dbType) {
+    return Schema.Array(runtimeSchemaForDbType(dbType.element) ?? Schema.Unknown)
+  }
+  if ("fields" in dbType) {
+    const fields = Object.fromEntries(
+      Object.entries(dbType.fields).map(([key, field]) => [key, runtimeSchemaForDbType(field) ?? Schema.Unknown])
+    )
+    return Schema.Struct(fields as Record<string, RuntimeSchema>)
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return JsonValueSchema
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return Schema.String
+  }
+  const runtimeTag = runtimeTagOfBaseDbType(dbType.dialect, dbType.kind)
+  return runtimeTag === undefined ? undefined : runtimeSchemaForTag(runtimeTag)
+}
+
+const makeSchemaFromAst = (ast: SchemaAST.AST): RuntimeSchema =>
+  Schema.make(ast)
+
+const unionAst = (asts: ReadonlyArray<SchemaAST.AST>): SchemaAST.AST | undefined => {
+  if (asts.length === 0) {
+    return undefined
+  }
+  if (asts.length === 1) {
+    return asts[0]
+  }
+  return SchemaAST.Union.make(asts)
+}
+
+const propertyAstOf = (
+  ast: SchemaAST.AST,
+  key: string
+): SchemaAST.AST | undefined => {
+  switch (ast._tag) {
+    case "Transformation":
+      return propertyAstOf(SchemaAST.typeAST(ast), key)
+    case "Refinement":
+      return propertyAstOf(ast.from, key)
+    case "Suspend":
+      return propertyAstOf(ast.f(), key)
+    case "TypeLiteral": {
+      const property = ast.propertySignatures.find((entry) => entry.name === key)
+      if (property !== undefined) {
+        return property.type
+      }
+      const index = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword")
+      return index?.type
+    }
+    case "Union": {
+      const values = ast.types.flatMap((member) => {
+        const next = propertyAstOf(member, key)
+        return next === undefined ? [] : [next]
+      })
+      return unionAst(values)
+    }
+    default:
+      return undefined
+  }
+}
+
+const numberAstOf = (
+  ast: SchemaAST.AST,
+  index: number
+): SchemaAST.AST | undefined => {
+  switch (ast._tag) {
+    case "Transformation":
+      return numberAstOf(SchemaAST.typeAST(ast), index)
+    case "Refinement":
+      return numberAstOf(ast.from, index)
+    case "Suspend":
+      return numberAstOf(ast.f(), index)
+    case "TupleType": {
+      const element = ast.elements[index]
+      if (element !== undefined) {
+        return element.type
+      }
+      if (ast.rest.length === 0) {
+        return undefined
+      }
+      return unionAst(ast.rest.map((entry) => entry.type))
+    }
+    case "Union": {
+      const values = ast.types.flatMap((member) => {
+        const next = numberAstOf(member, index)
+        return next === undefined ? [] : [next]
+      })
+      return unionAst(values)
+    }
+    default:
+      return undefined
+  }
+}
+
+const exactJsonSegments = (
+  segments: readonly JsonPath.CanonicalSegment[]
+): segments is readonly (JsonPath.KeySegment | JsonPath.IndexSegment)[] =>
+  segments.every((segment) => segment.kind === "key" || segment.kind === "index")
+
+const schemaAstAtExactJsonPath = (
+  schema: RuntimeSchema,
+  segments: readonly JsonPath.CanonicalSegment[]
+): SchemaAST.AST | undefined => {
+  let current: SchemaAST.AST = SchemaAST.typeAST(schema.ast)
+  for (const segment of segments) {
+    if (segment.kind === "key") {
+      const property = propertyAstOf(current, segment.key)
+      if (property === undefined) {
+        return undefined
+      }
+      current = property
+      continue
+    }
+    if (segment.kind === "index") {
+      const next = numberAstOf(current, segment.index)
+      if (next === undefined) {
+        return undefined
+      }
+      current = next
+      continue
+    }
+    return undefined
+  }
+  return current
+}
+
+const unionSchemas = (schemas: ReadonlyArray<RuntimeSchema | undefined>): RuntimeSchema | undefined => {
+  const resolved = schemas.filter((schema): schema is RuntimeSchema => schema !== undefined)
+  if (resolved.length === 0) {
+    return undefined
+  }
+  if (resolved.length === 1) {
+    return resolved[0]
+  }
+  return Schema.Union(...resolved)
+}
+
+const firstSelectedExpression = (
+  plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>
+): Expression.Any | undefined => {
+  const selection = Query.getAst(plan).select
+  return flattenSelection(selection as Record<string, unknown>)[0]?.expression
+}
+
+const isJsonCompatibleAst = (ast: SchemaAST.AST): boolean => {
+  switch (ast._tag) {
+    case "StringKeyword":
+    case "NumberKeyword":
+    case "BooleanKeyword":
+    case "TupleType":
+    case "TypeLiteral":
+      return true
+    case "Literal":
+      return ast.literal === null ||
+        typeof ast.literal === "string" ||
+        typeof ast.literal === "number" ||
+        typeof ast.literal === "boolean"
+    case "Union":
+      return ast.types.every(isJsonCompatibleAst)
+    case "Transformation":
+      return isJsonCompatibleAst(SchemaAST.typeAST(ast))
+    case "Suspend":
+      return isJsonCompatibleAst(ast.f())
+    default:
+      return false
+  }
+}
+
+const jsonCompatibleSchema = (schema: RuntimeSchema | undefined): RuntimeSchema | undefined => {
+  if (schema === undefined) {
+    return undefined
+  }
+  const ast = SchemaAST.typeAST(schema.ast)
+  return isJsonCompatibleAst(ast) ? schema : JsonValueSchema
+}
+
+const buildStructSchema = (
+  entries: readonly { readonly key: string; readonly value: Expression.Any }[]
+): RuntimeSchema => {
+  const fields = Object.fromEntries(
+    entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value) ?? 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 deriveRuntimeSchema = (expression: Expression.Any): RuntimeSchema | undefined => {
+  const state = expression[Expression.TypeId]
+  if (state.runtimeSchema !== undefined) {
+    return state.runtimeSchema
+  }
+  const ast = (expression as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  switch (ast.kind) {
+    case "column":
+    case "excluded":
+      return state.runtimeSchema
+    case "literal":
+      if (ast.value === null) {
+        return Schema.Null
+      }
+      if (typeof ast.value === "string" || typeof ast.value === "number" || typeof ast.value === "boolean") {
+        return Schema.Literal(ast.value)
+      }
+      return runtimeSchemaForDbType(state.dbType)
+    case "cast":
+      return runtimeSchemaForDbType(ast.target)
+    case "isNull":
+    case "isNotNull":
+    case "not":
+    case "eq":
+    case "neq":
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte":
+    case "like":
+    case "ilike":
+    case "isDistinctFrom":
+    case "isNotDistinctFrom":
+    case "contains":
+    case "containedBy":
+    case "overlaps":
+    case "and":
+    case "or":
+    case "in":
+    case "notIn":
+    case "between":
+    case "exists":
+    case "inSubquery":
+    case "comparisonAny":
+    case "comparisonAll":
+    case "jsonHasKey":
+    case "jsonKeyExists":
+    case "jsonHasAnyKeys":
+    case "jsonHasAllKeys":
+    case "jsonPathExists":
+    case "jsonPathMatch":
+      return Schema.Boolean
+    case "upper":
+    case "lower":
+    case "concat":
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText":
+    case "jsonTypeOf":
+      return Schema.String
+    case "count":
+    case "jsonLength":
+      return Schema.Number
+    case "max":
+    case "min":
+      return expressionRuntimeSchema(ast.value)
+    case "case":
+      return unionSchemas([
+        ...ast.branches.map((branch) => expressionRuntimeSchema(branch.then)),
+        expressionRuntimeSchema(ast.else)
+      ])
+    case "coalesce":
+      return unionSchemas(ast.values.map(expressionRuntimeSchema))
+    case "scalarSubquery":
+      {
+        const selection = firstSelectedExpression(ast.plan)
+        return selection === undefined ? undefined : expressionRuntimeSchema(selection)
+      }
+    case "window":
+      return ast.function === "over" && ast.value !== undefined
+        ? expressionRuntimeSchema(ast.value)
+        : Schema.Number
+    case "jsonGet":
+    case "jsonPath":
+    case "jsonAccess":
+    case "jsonTraverse": {
+      const baseSchema = expressionRuntimeSchema(ast.base!)
+      const segments = ast.segments
+      if (baseSchema === undefined || segments === undefined || !exactJsonSegments(segments)) {
+        return JsonValueSchema
+      }
+      const subAst = schemaAstAtExactJsonPath(baseSchema, segments)
+      return subAst === undefined ? JsonValueSchema : makeSchemaFromAst(subAst)
+    }
+    case "jsonDelete":
+    case "jsonDeletePath":
+    case "jsonRemove":
+    case "jsonSet":
+    case "jsonInsert":
+      return expressionRuntimeSchema(ast.base!)
+    case "jsonStripNulls":
+      return expressionRuntimeSchema(ast.value!)
+    case "jsonConcat":
+    case "jsonMerge":
+      return JsonValueSchema
+    case "jsonBuildObject":
+      return buildStructSchema(ast.entries ?? [])
+    case "jsonBuildArray":
+      return buildTupleSchema(ast.values ?? [])
+    case "jsonToJson":
+    case "jsonToJsonb":
+      return jsonCompatibleSchema(expressionRuntimeSchema(ast.value!))
+    case "jsonKeys":
+      return Schema.Array(Schema.String)
+  }
+}
+
+export const expressionRuntimeSchema = (
+  expression: Expression.Any
+): RuntimeSchema | undefined => {
+  const cached = schemaCache.get(expression)
+  if (cached !== undefined || schemaCache.has(expression)) {
+    return cached
+  }
+  const resolved = deriveRuntimeSchema(expression) ?? runtimeSchemaForDbType(expression[Expression.TypeId].dbType)
+  schemaCache.set(expression, resolved)
+  return resolved
+}

package/src/internal/runtime-value.ts

@@ -0,0 +1,85 @@
+import type * as Brand from "effect/Brand"
+import * as Schema from "effect/Schema"
+
+import type { JsonPrimitive, JsonValue } from "./json/types.js"
+
+export type { JsonPrimitive, JsonValue } from "./json/types.js"
+
+export type LocalDateString = string & Brand.Brand<"LocalDateString">
+export type LocalTimeString = string & Brand.Brand<"LocalTimeString">
+export type OffsetTimeString = string & Brand.Brand<"OffsetTimeString">
+export type LocalDateTimeString = string & Brand.Brand<"LocalDateTimeString">
+export type InstantString = string & Brand.Brand<"InstantString">
+export type YearString = string & Brand.Brand<"YearString">
+export type BigIntString = string & Brand.Brand<"BigIntString">
+export type DecimalString = string & Brand.Brand<"DecimalString">
+
+const brandString = <BrandName extends string>(
+  pattern: RegExp,
+  brand: BrandName
+): Schema.Schema<string & Brand.Brand<BrandName>> =>
+  Schema.String.pipe(
+    Schema.pattern(pattern),
+    Schema.brand(brand)
+  ) as unknown as Schema.Schema<string & Brand.Brand<BrandName>>
+
+export const LocalDateStringSchema = brandString(
+  /^\d{4}-\d{2}-\d{2}$/,
+  "LocalDateString"
+)
+
+export const LocalTimeStringSchema = brandString(
+  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
+  "LocalTimeString"
+)
+
+export const OffsetTimeStringSchema = brandString(
+  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
+  "OffsetTimeString"
+)
+
+export const LocalDateTimeStringSchema = brandString(
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
+  "LocalDateTimeString"
+)
+
+export const InstantStringSchema = brandString(
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
+  "InstantString"
+)
+
+export const YearStringSchema = brandString(
+  /^\d{4}$/,
+  "YearString"
+)
+
+export const BigIntStringSchema = brandString(
+  /^-?\d+$/,
+  "BigIntString"
+)
+
+export const DecimalStringSchema = brandString(
+  /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/,
+  "DecimalString"
+)
+
+export const JsonValueSchema: Schema.Schema<JsonValue> = Schema.suspend(() =>
+  Schema.Union(
+    Schema.String,
+    Schema.Number,
+    Schema.Boolean,
+    Schema.Null,
+    Schema.Array(JsonValueSchema),
+    Schema.Record({
+      key: Schema.String,
+      value: JsonValueSchema
+    })
+  )
+)
+
+export const JsonPrimitiveSchema: Schema.Schema<JsonPrimitive> = Schema.Union(
+  Schema.String,
+  Schema.Number,
+  Schema.Boolean,
+  Schema.Null
+)

package/src/internal/schema-derivation.ts

@@ -0,0 +1,131 @@
+import * as VariantSchema from "@effect/experimental/VariantSchema"
+import * as Schema from "effect/Schema"
+
+import {
+  type AnyColumnDefinition,
+  type HasDefault,
+  type InsertType,
+  type IsGenerated,
+  type IsNullable,
+  type SelectType,
+  type UpdateType
+} from "./column-state.js"
+
+/** Variant-schema helper used to derive select / insert / update schemas. */
+export const TableSchema = VariantSchema.make({
+  variants: ["select", "insert", "update"] as const,
+  defaultVariant: "select"
+})
+
+type Variants = "select" | "insert" | "update"
+
+/** Normalized field map used by table definitions. */
+export type TableFieldMap = Record<string, AnyColumnDefinition>
+
+type GeneratedKeys<Fields extends TableFieldMap> = {
+  [K in keyof Fields]: IsGenerated<Fields[K]> extends true ? K : never
+}[keyof Fields]
+
+type OptionalInsertKeys<Fields extends TableFieldMap> = {
+  [K in keyof Fields]:
+    IsGenerated<Fields[K]> extends true ? never :
+      IsNullable<Fields[K]> extends true ? K :
+        HasDefault<Fields[K]> extends true ? K :
+          never
+}[keyof Fields]
+
+type RequiredInsertKeys<Fields extends TableFieldMap> = Exclude<keyof Fields, GeneratedKeys<Fields> | OptionalInsertKeys<Fields>>
+
+type UpdateKeys<Fields extends TableFieldMap, PrimaryKey extends keyof Fields> = Exclude<
+  keyof Fields,
+  GeneratedKeys<Fields> | PrimaryKey
+>
+
+type Simplify<T> = { [K in keyof T]: T[K] } & {}
+
+/** Row shape returned by selecting from a table. */
+export type SelectRow<Fields extends TableFieldMap> = Simplify<{
+  [K in keyof Fields]: SelectType<Fields[K]>
+}>
+
+/** 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]> }
+>
+
+/** Update payload derived from a table field map and primary key. */
+export type UpdateRow<Fields extends TableFieldMap, PrimaryKey extends keyof Fields> = Simplify<
+  Partial<{
+    [K in UpdateKeys<Fields, PrimaryKey>]: UpdateType<Fields[K]>
+  }>
+>
+
+const selectSchema = (column: AnyColumnDefinition): Schema.Schema.Any =>
+  column.metadata.nullable ? Schema.NullOr(column.schema) : column.schema
+
+const insertSchema = (column: AnyColumnDefinition): any | undefined => {
+  if (column.metadata.generated) {
+    return undefined
+  }
+  const base = column.metadata.nullable ? Schema.NullOr(column.schema) : column.schema
+  return column.metadata.nullable || column.metadata.hasDefault ? Schema.optional(base) : base
+}
+
+const updateSchema = (
+  column: AnyColumnDefinition,
+  isPrimaryKey: boolean
+): any | undefined => {
+  if (column.metadata.generated || isPrimaryKey) {
+    return undefined
+  }
+  const base = column.metadata.nullable ? Schema.NullOr(column.schema) : column.schema
+  return Schema.optional(base)
+}
+
+/**
+ * Derives the `select`, `insert`, and `update` schemas for a table.
+ *
+ * This is the central place where the column capability flags are turned into
+ * real runtime schemas.
+ */
+export const deriveSchemas = <
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): {
+  readonly select: Schema.Schema<SelectRow<Fields>>
+  readonly insert: Schema.Schema<InsertRow<Fields>>
+  readonly update: Schema.Schema<UpdateRow<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),
+      insert: undefined,
+      update: undefined
+    }
+    const insert = insertSchema(column)
+    const update = updateSchema(column, primaryKeySet.has(key))
+    if (insert !== undefined) {
+      config.insert = insert
+    } else {
+      delete config.insert
+    }
+    if (update !== undefined) {
+      config.update = update
+    } else {
+      delete config.update
+    }
+    variants[key] = TableSchema.Field(config)
+  }
+  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>>
+  }
+}