effect-qb 0.16.0 → 0.17.0

package/src/internal/runtime/normalize.ts

@@ -1,13 +1,30 @@
 import type * as Expression from "../scalar.js"
 import type { RuntimeTag } from "../datatypes/shape.js"
+import {
+  canonicalizeBigIntString,
+  canonicalizeDecimalString,
+  isValidInstantString,
+  isValidLocalDateString,
+  isValidLocalDateTimeString,
+  isValidLocalTimeString,
+  isValidOffsetTimeString
+} from "./value.js"
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value)
 
+const isPlainRecord = (value: unknown): value is Record<string, unknown> => {
+  if (!isRecord(value)) {
+    return false
+  }
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
 const pad = (value: number, width = 2): string => value.toString().padStart(width, "0")
 
 const formatLocalDate = (value: Date): string =>
-  `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`
+  `${pad(value.getUTCFullYear(), 4)}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`
 
 const formatLocalTime = (value: Date): string => {
   const milliseconds = value.getUTCMilliseconds()
@@ -34,12 +51,17 @@ const expectString = (value: unknown, label: string): string => {
   throw new Error(`Expected ${label} as string`)
 }
 
+const finiteNumberStringPattern = /^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:[eE][+-]?\d+)?$/
+
 const normalizeNumber = (value: unknown): number => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value
   }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value)
+  if (typeof value === "string") {
+    const trimmed = value.trim()
+    const parsed = finiteNumberStringPattern.test(trimmed)
+      ? Number(trimmed)
+      : Number.NaN
     if (Number.isFinite(parsed)) {
       return parsed
     }
@@ -81,27 +103,12 @@ const normalizeBigIntString = (value: unknown): string => {
   if (typeof value === "number" && Number.isSafeInteger(value)) {
     return BigInt(value).toString()
   }
-  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
-    return BigInt(value.trim()).toString()
+  if (typeof value === "string") {
+    return canonicalizeBigIntString(value)
   }
   throw new Error("Expected an integer-like bigint value")
 }
 
-const canonicalizeDecimalString = (input: string): string => {
-  const trimmed = input.trim()
-  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed)
-  if (match === null) {
-    throw new Error("Expected a decimal string")
-  }
-  const sign = match[1] === "-" ? "-" : ""
-  const integer = match[2]!.replace(/^0+(?=\d)/, "") || "0"
-  const fraction = (match[3] ?? "").replace(/0+$/, "")
-  if (fraction.length === 0) {
-    return `${sign}${integer}`
-  }
-  return `${sign}${integer}.${fraction}`
-}
-
 const normalizeDecimalString = (value: unknown): string => {
   if (typeof value === "string") {
     return canonicalizeDecimalString(value)
@@ -121,12 +128,15 @@ const normalizeLocalDate = (value: unknown): string => {
     return formatLocalDate(value)
   }
   const raw = expectString(value, "local date").trim()
-  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+  if (isValidLocalDateString(raw)) {
     return raw
   }
-  const parsed = new Date(raw)
-  if (!Number.isNaN(parsed.getTime())) {
-    return formatLocalDate(parsed)
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z")
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant)
+    if (!Number.isNaN(parsed.getTime())) {
+      return formatLocalDate(parsed)
+    }
   }
   throw new Error("Expected a local-date value")
 }
@@ -136,7 +146,7 @@ const normalizeLocalTime = (value: unknown): string => {
     return formatLocalTime(value)
   }
   const raw = expectString(value, "local time").trim()
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
+  if (isValidLocalTimeString(raw)) {
     return raw
   }
   throw new Error("Expected a local-time value")
@@ -147,7 +157,7 @@ const normalizeOffsetTime = (value: unknown): string => {
     return `${formatLocalTime(value)}Z`
   }
   const raw = expectString(value, "offset time").trim()
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
+  if (isValidOffsetTimeString(raw)) {
     return raw
   }
   throw new Error("Expected an offset-time value")
@@ -158,11 +168,13 @@ const normalizeLocalDateTime = (value: unknown): string => {
     return formatLocalDateTime(value)
   }
   const raw = expectString(value, "local datetime").trim()
-  if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
-    return raw.replace(" ", "T")
+  const canonicalLocalDateTime = raw.replace(" ", "T")
+  if (isValidLocalDateTimeString(canonicalLocalDateTime)) {
+    return canonicalLocalDateTime
   }
-  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
-    const parsed = new Date(raw)
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z")
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant)
     if (!Number.isNaN(parsed.getTime())) {
       return formatLocalDateTime(parsed)
     }
@@ -178,7 +190,11 @@ const normalizeInstant = (value: unknown): string => {
   if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {
     throw new Error("Instant values require a timezone offset")
   }
-  const parsed = new Date(raw)
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z")
+  if (!isValidInstantString(canonicalInstant)) {
+    throw new Error("Expected an ISO instant value")
+  }
+  const parsed = new Date(canonicalInstant)
   if (Number.isNaN(parsed.getTime())) {
     throw new Error("Expected an ISO instant value")
   }
@@ -209,20 +225,21 @@ const normalizeBytes = (value: unknown): Uint8Array => {
   throw new Error("Expected a byte array value")
 }
 
-const isJsonValue = (value: unknown): boolean => {
+export const isJsonValue = (value: unknown): boolean => {
   if (value === null) {
     return true
   }
   switch (typeof value) {
     case "string":
-    case "number":
     case "boolean":
       return true
+    case "number":
+      return Number.isFinite(value)
     case "object":
       if (Array.isArray(value)) {
         return value.every(isJsonValue)
       }
-      return isRecord(value) && Object.values(value).every(isJsonValue)
+      return isPlainRecord(value) && Object.values(value).every(isJsonValue)
     default:
       return false
   }
@@ -230,11 +247,18 @@ const isJsonValue = (value: unknown): boolean => {
 
 const normalizeJson = (value: unknown): unknown => {
   if (typeof value === "string") {
-    const parsed = JSON.parse(value)
-    if (isJsonValue(parsed)) {
-      return parsed
+    try {
+      const parsed = JSON.parse(value)
+      if (isJsonValue(parsed)) {
+        return parsed
+      }
+      throw new Error("Parsed JSON value is not a valid JSON runtime")
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return value
+      }
+      throw error
     }
-    throw new Error("Parsed JSON value is not a valid JSON runtime")
   }
   if (isJsonValue(value)) {
     return value

package/src/internal/runtime/schema.ts

@@ -38,12 +38,14 @@ const schemaCache = new WeakMap<Expression.Any, RuntimeSchema | undefined>()
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value)
 
+const FiniteNumberSchema = Schema.Number.pipe(Schema.finite())
+
 const runtimeSchemaForTag = (tag: RuntimeTag): RuntimeSchema | undefined => {
   switch (tag) {
     case "string":
       return Schema.String
     case "number":
-      return Schema.Number
+      return FiniteNumberSchema
     case "bigintString":
       return BigIntStringSchema
     case "boolean":
@@ -388,7 +390,7 @@ const deriveRuntimeSchema = (
       return Schema.String
     case "count":
     case "jsonLength":
-      return Schema.Number
+      return FiniteNumberSchema
     case "max":
     case "min":
       return expressionRuntimeSchema(ast.value, context)
@@ -404,7 +406,7 @@ const deriveRuntimeSchema = (
     case "window":
       return ast.function === "over" && ast.value !== undefined
         ? expressionRuntimeSchema(ast.value, context)
-        : Schema.Number
+        : FiniteNumberSchema
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":

package/src/internal/runtime/value.ts

@@ -23,50 +23,173 @@ const brandString = <BrandName extends string>(
     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 localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/
 
-export const LocalTimeStringSchema = brandString(
-  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
-  "LocalTimeString"
-)
+export const isValidLocalDateString = (value: string): boolean => {
+  const match = localDatePattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  const year = Number(match[1])
+  const month = Number(match[2])
+  const day = Number(match[3])
+  const parsed = new Date(Date.UTC(year, month - 1, day))
+  parsed.setUTCFullYear(year)
+  return parsed.getUTCFullYear() === year &&
+    parsed.getUTCMonth() === month - 1 &&
+    parsed.getUTCDate() === day
+}
 
-export const OffsetTimeStringSchema = brandString(
-  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
-  "OffsetTimeString"
-)
+export const localTimePattern = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/
 
-export const LocalDateTimeStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
-  "LocalDateTimeString"
-)
+export const isValidLocalTimeString = (value: string): boolean => {
+  const match = localTimePattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  const hour = Number(match[1])
+  const minute = Number(match[2])
+  const second = Number(match[3])
+  return hour >= 0 && hour <= 23 &&
+    minute >= 0 && minute <= 59 &&
+    second >= 0 && second <= 59
+}
 
-export const InstantStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
-  "InstantString"
-)
+const offsetPattern = /^(?:Z|[+-](\d{2}):(\d{2}))$/
+
+const isValidOffset = (value: string): boolean => {
+  const match = offsetPattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  if (value === "Z") {
+    return true
+  }
+  const hour = Number(match[1])
+  const minute = Number(match[2])
+  return hour >= 0 && hour <= 23 &&
+    minute >= 0 && minute <= 59
+}
+
+export const offsetTimePattern = /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/
+
+export const isValidOffsetTimeString = (value: string): boolean => {
+  const match = offsetTimePattern.exec(value)
+  return match !== null &&
+    isValidLocalTimeString(match[1]!) &&
+    isValidOffset(match[2]!)
+}
+
+export const localDateTimePattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/
+
+export const isValidLocalDateTimeString = (value: string): boolean => {
+  const match = localDateTimePattern.exec(value)
+  return match !== null &&
+    isValidLocalDateString(match[1]!) &&
+    isValidLocalTimeString(match[2]!)
+}
+
+export const instantPattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/
+
+export const isValidInstantString = (value: string): boolean => {
+  const match = instantPattern.exec(value)
+  return match !== null &&
+    isValidLocalDateString(match[1]!) &&
+    isValidLocalTimeString(match[2]!) &&
+    isValidOffset(match[3]!)
+}
+
+export const LocalDateStringSchema = Schema.String.pipe(
+  Schema.pattern(localDatePattern),
+  Schema.filter(isValidLocalDateString),
+  Schema.brand("LocalDateString")
+) as unknown as Schema.Schema<LocalDateString>
+
+export const LocalTimeStringSchema = Schema.String.pipe(
+  Schema.pattern(localTimePattern),
+  Schema.filter(isValidLocalTimeString),
+  Schema.brand("LocalTimeString")
+) as unknown as Schema.Schema<LocalTimeString>
+
+export const OffsetTimeStringSchema = Schema.String.pipe(
+  Schema.pattern(offsetTimePattern),
+  Schema.filter(isValidOffsetTimeString),
+  Schema.brand("OffsetTimeString")
+) as unknown as Schema.Schema<OffsetTimeString>
+
+export const LocalDateTimeStringSchema = Schema.String.pipe(
+  Schema.pattern(localDateTimePattern),
+  Schema.filter(isValidLocalDateTimeString),
+  Schema.brand("LocalDateTimeString")
+) as unknown as Schema.Schema<LocalDateTimeString>
+
+export const InstantStringSchema = Schema.String.pipe(
+  Schema.pattern(instantPattern),
+  Schema.filter(isValidInstantString),
+  Schema.brand("InstantString")
+) as unknown as Schema.Schema<InstantString>
 
 export const YearStringSchema = brandString(
   /^\d{4}$/,
   "YearString"
 )
 
-export const BigIntStringSchema = brandString(
-  /^-?\d+$/,
-  "BigIntString"
-)
+export const canonicalizeBigIntString = (input: string): string => {
+  const trimmed = input.trim()
+  if (!/^-?\d+$/.test(trimmed)) {
+    throw new Error("Expected an integer-like bigint value")
+  }
+  return BigInt(trimmed).toString()
+}
 
-export const DecimalStringSchema = brandString(
-  /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/,
-  "DecimalString"
-)
+export const isCanonicalBigIntString = (value: string): boolean => {
+  try {
+    return canonicalizeBigIntString(value) === value
+  } catch {
+    return false
+  }
+}
+
+export const canonicalizeDecimalString = (input: string): string => {
+  const trimmed = input.trim()
+  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed)
+  if (match === null) {
+    throw new Error("Expected a decimal string")
+  }
+  const sign = match[1] === "-" ? "-" : ""
+  const integer = match[2]!.replace(/^0+(?=\d)/, "") || "0"
+  const fraction = (match[3] ?? "").replace(/0+$/, "")
+  if (fraction.length === 0) {
+    if (integer === "0") {
+      return "0"
+    }
+    return `${sign}${integer}`
+  }
+  return `${sign}${integer}.${fraction}`
+}
+
+export const isCanonicalDecimalString = (value: string): boolean => {
+  try {
+    return canonicalizeDecimalString(value) === value
+  } catch {
+    return false
+  }
+}
+
+export const BigIntStringSchema = Schema.String.pipe(
+  Schema.filter(isCanonicalBigIntString),
+  Schema.brand("BigIntString")
+) as unknown as Schema.Schema<BigIntString>
+
+export const DecimalStringSchema = Schema.String.pipe(
+  Schema.filter(isCanonicalDecimalString),
+  Schema.brand("DecimalString")
+) as unknown as Schema.Schema<DecimalString>
 
 export const JsonValueSchema: Schema.Schema<JsonValue> = Schema.suspend(() =>
   Schema.Union(
     Schema.String,
-    Schema.Number,
+    Schema.Number.pipe(Schema.finite()),
     Schema.Boolean,
     Schema.Null,
     Schema.Array(JsonValueSchema),
@@ -79,7 +202,7 @@ export const JsonValueSchema: Schema.Schema<JsonValue> = Schema.suspend(() =>
 
 export const JsonPrimitiveSchema: Schema.Schema<JsonPrimitive> = Schema.Union(
   Schema.String,
-  Schema.Number,
+  Schema.Number.pipe(Schema.finite()),
   Schema.Boolean,
   Schema.Null
 )

package/src/internal/table-options.ts

@@ -15,6 +15,30 @@ export type DdlExpressionLike = AnyExpression | AnySchemaExpression
 
 export type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull" | "setDefault"
 
+const referentialActionError = "Foreign key action must be noAction, restrict, cascade, setNull, or setDefault"
+
+export const renderReferentialAction = (action: unknown): string => {
+  switch (action) {
+    case "noAction":
+      return "no action"
+    case "restrict":
+      return "restrict"
+    case "cascade":
+      return "cascade"
+    case "setNull":
+      return "set null"
+    case "setDefault":
+      return "set default"
+  }
+  throw new Error(referentialActionError)
+}
+
+const validateReferentialAction = (action: unknown): void => {
+  if (action !== undefined) {
+    renderReferentialAction(action)
+  }
+}
+
 export type IndexKeySpec =
   | {
       readonly kind: "column"
@@ -107,6 +131,18 @@ type TupleFromColumns<Columns> = Columns extends readonly [infer Head extends st
       ? readonly [Columns]
       : never
 
+export type NonEmptyColumnInput<Columns extends string | readonly string[]> =
+  TupleFromColumns<Columns> extends never ? never : Columns
+
+export type MatchingColumnArityInput<
+  Left extends string | readonly string[],
+  Right extends string | readonly string[]
+> = TupleFromColumns<Left>["length"] extends TupleFromColumns<Right>["length"]
+  ? TupleFromColumns<Right>["length"] extends TupleFromColumns<Left>["length"]
+    ? unknown
+    : never
+  : never
+
 type AssertKnownColumns<Fields extends TableFieldMap, Columns extends readonly string[]> = Exclude<
   Columns[number],
   ColumnNameUnion<Fields>
@@ -114,6 +150,47 @@ type AssertKnownColumns<Fields extends TableFieldMap, Columns extends readonly s
   ? Columns
   : never
 
+type IndexKeyColumnNames<Keys> = Keys extends readonly (infer Key)[]
+  ? Key extends { readonly kind: "column"; readonly column: infer Column extends string }
+    ? Column
+    : never
+  : never
+
+type IndexOptionColumnNames<Spec> =
+  | (Spec extends { readonly columns: infer Columns extends readonly string[] } ? Columns[number] : never)
+  | (Spec extends { readonly include: infer Include extends readonly string[] } ? Include[number] : never)
+  | (Spec extends { readonly keys: infer Keys } ? IndexKeyColumnNames<Keys> : never)
+
+type ForeignKeyReferencedColumnNames<Spec> = Spec extends { readonly references: () => infer Reference }
+  ? Reference extends { readonly columns: infer Columns extends readonly string[] }
+    ? Columns[number]
+    : never
+  : never
+
+type ForeignKeyKnownReferencedColumnNames<Spec> = Spec extends { readonly references: () => infer Reference }
+  ? Reference extends { readonly knownColumns: infer KnownColumns extends readonly string[] }
+    ? KnownColumns[number]
+    : string
+  : string
+
+type AssertKnownColumnNames<Fields extends TableFieldMap, Columns extends string> = [Columns] extends [never]
+  ? true
+  : string extends Columns
+    ? true
+    : Exclude<Columns, ColumnNameUnion<Fields>> extends never
+      ? true
+      : false
+
+type AssertKnownReferenceColumnNames<KnownColumns extends string, Columns extends string> = [Columns] extends [never]
+  ? true
+  : string extends Columns
+    ? true
+    : string extends KnownColumns
+      ? true
+      : Exclude<Columns, KnownColumns> extends never
+        ? true
+        : false
+
 type AssertPrimaryKeyColumns<
   Fields extends TableFieldMap,
   Columns extends readonly string[]
@@ -159,6 +236,8 @@ export const collectInlineOptions = <Fields extends TableFieldMap>(
       })
     }
     if (column.metadata.references) {
+      validateReferentialAction(column.metadata.references.onUpdate)
+      validateReferentialAction(column.metadata.references.onDelete)
       const local = [columnName] as ColumnList
       options.push({
         kind: "foreignKey",
@@ -254,6 +333,8 @@ export const validateOptions = <Fields extends TableFieldMap>(
           }
         }
         if (option.kind === "foreignKey") {
+          validateReferentialAction(option.onUpdate)
+          validateReferentialAction(option.onDelete)
           const reference = option.references()
           if (reference.columns.length !== columns.length) {
             throw new Error(`Foreign key on table '${tableName}' must reference the same number of columns`)
@@ -278,7 +359,7 @@ export const validateOptions = <Fields extends TableFieldMap>(
               throw new Error(`Unknown index key column '${key.column}' on table '${tableName}'`)
             }
           }
-          if (option.columns === undefined && (option.keys === undefined || option.keys.length === 0)) {
+          if (columns.length === 0 && (option.keys === undefined || option.keys.length === 0)) {
             throw new Error(`Index on table '${tableName}' requires at least one column or key`)
           }
         }
@@ -308,5 +389,31 @@ export type ValidatePrimaryKeyColumns<
   Columns extends readonly string[]
 > = AssertPrimaryKeyColumns<Fields, AssertKnownColumns<Fields, Columns>>
 
+/** Compile-time validation that index columns, included columns, and column keys exist on the table. */
+export type ValidateIndexOptionColumns<
+  Fields extends TableFieldMap,
+  Spec
+> = AssertKnownColumnNames<Fields, IndexOptionColumnNames<Spec>> extends true ? Spec : never
+
+/** Compile-time validation that foreign keys reference known local and target columns. */
+export type ValidateForeignKeyOptionColumns<
+  Fields extends TableFieldMap,
+  Spec
+> = Spec extends { readonly columns: infer Columns extends readonly string[] }
+  ? AssertKnownColumns<Fields, Columns> extends never
+    ? never
+    : AssertKnownReferenceColumnNames<
+        ForeignKeyKnownReferencedColumnNames<Spec>,
+        ForeignKeyReferencedColumnNames<Spec>
+      > extends true
+      ? Spec
+      : never
+  : AssertKnownReferenceColumnNames<
+      ForeignKeyKnownReferencedColumnNames<Spec>,
+      ForeignKeyReferencedColumnNames<Spec>
+    > extends true
+    ? Spec
+    : never
+
 /** Normalizes a public column input into the internal tuple form. */
 export type NormalizeColumns<Columns extends string | readonly string[]> = TupleFromColumns<Columns>