effect-qb 0.16.0 → 0.19.0

package/src/internal/runtime/driver-value-mapping.ts

@@ -84,6 +84,26 @@ const findMapping = <Key extends MappingKey>(
   return undefined
 }
 
+const isJsonDbType = (dbType: Expression.DbType.Any | undefined): boolean => {
+  if (dbType === undefined) {
+    return false
+  }
+  if ("base" in dbType) {
+    return isJsonDbType(dbType.base)
+  }
+  if (!("variant" in dbType)) {
+    return false
+  }
+  const variant = dbType.variant as string
+  return variant === "json" || variant === "jsonb"
+}
+
+const schemaAccepts = (
+  schema: Schema.Schema.Any | undefined,
+  value: unknown
+): boolean =>
+  schema !== undefined && (Schema.is(schema) as (candidate: unknown) => boolean)(value)
+
 const encodeWithSchema = (
   schema: Schema.Schema.Any | undefined,
   value: unknown
@@ -100,6 +120,32 @@ const encodeWithSchema = (
   }
 }
 
+const normalizeJsonDriverString = (
+  value: string,
+  context: DriverValueContext
+): unknown | undefined => {
+  if (!isJsonDbType(context.dbType) || context.runtimeSchema === undefined) {
+    return undefined
+  }
+  try {
+    const parsed = JSON.parse(value)
+    if (value.trimStart().startsWith("\"") && schemaAccepts(context.runtimeSchema, parsed)) {
+      return parsed
+    }
+    if (schemaAccepts(context.runtimeSchema, value) && !schemaAccepts(context.runtimeSchema, parsed)) {
+      return value
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError && schemaAccepts(context.runtimeSchema, value)) {
+      return value
+    }
+    if (!(error instanceof SyntaxError)) {
+      throw error
+    }
+  }
+  return undefined
+}
+
 export const toDriverValue = (
   value: unknown,
   context: DriverValueContext
@@ -107,6 +153,9 @@ export const toDriverValue = (
   if (value === null) {
     return null
   }
+  if (value instanceof Date && Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value")
+  }
   const dbType = context.dbType
   const encoded = encodeWithSchema(context.runtimeSchema, value)
   let current = encoded.value
@@ -114,6 +163,9 @@ export const toDriverValue = (
   if (custom !== undefined && dbType !== undefined) {
     return custom(current, dbType)
   }
+  if (encoded.encoded && typeof current === "string" && isJsonDbType(dbType)) {
+    return current
+  }
   return dbType === undefined || !encoded.encoded
     ? current
     : normalizeDbValue(dbType, current)
@@ -131,6 +183,12 @@ export const fromDriverValue = (
   if (custom !== undefined && dbType !== undefined) {
     return custom(value, dbType)
   }
+  if (typeof value === "string") {
+    const normalizedJsonString = normalizeJsonDriverString(value, context)
+    if (normalizedJsonString !== undefined) {
+      return normalizedJsonString
+    }
+  }
   return dbType === undefined
     ? value
     : normalizeDbValue(dbType, value)

package/src/internal/runtime/normalize.ts

@@ -1,13 +1,37 @@
 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 validDate = (value: Date): Date => {
+  if (Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value")
+  }
+  return value
+}
+
 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 +58,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 +110,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)
@@ -118,25 +132,28 @@ const normalizeDecimalString = (value: unknown): string => {
 
 const normalizeLocalDate = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalDate(value)
+    return formatLocalDate(validDate(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")
 }
 
 const normalizeLocalTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalTime(value)
+    return formatLocalTime(validDate(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")
@@ -144,10 +161,10 @@ const normalizeLocalTime = (value: unknown): string => {
 
 const normalizeOffsetTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return `${formatLocalTime(value)}Z`
+    return `${formatLocalTime(validDate(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")
@@ -155,14 +172,16 @@ const normalizeOffsetTime = (value: unknown): string => {
 
 const normalizeLocalDateTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalDateTime(value)
+    return formatLocalDateTime(validDate(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)
     }
@@ -172,13 +191,17 @@ const normalizeLocalDateTime = (value: unknown): string => {
 
 const normalizeInstant = (value: unknown): string => {
   if (value instanceof Date) {
-    return value.toISOString()
+    return validDate(value).toISOString()
   }
   const raw = expectString(value, "instant").trim()
   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 +232,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 +254,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/scalar.ts

@@ -143,7 +143,12 @@ export interface DriverValueMapping {
   readonly jsonSelectSql?: (sql: string, dbType: DbType.Any) => string
 }
 
-export type DriverValueMappings = Readonly<Record<string, DriverValueMapping | undefined>>
+export type DriverValueMappings = Readonly<Partial<Record<string, DriverValueMapping>>>
+
+export type DriverValueMappingsFor<
+  Kind extends string,
+  Family extends string
+> = Readonly<Partial<Record<Kind | Family | RuntimeTag, DriverValueMapping>>>
 
 /** Canonical static metadata stored on an expression. */
 export interface State<