@minnowdb/core 0.6.9 → 0.7.1

package/dist/engine/sql-json.js

@@ -1,239 +1,220 @@
 import { stringArgument } from "./sql-semantics.js";
 import { externalSqlDomainValue, jsonDomainDocument } from "./sql-domains.js";
 import { MAX_CACHEABLE_TEXT_CHARACTERS, MAX_SQL_SCALAR_RESULT_CHARACTERS } from "./cache-limits.js";
-export function parseJsonPath(path, caller) {
-    const text = stringArgument(caller, path).trim();
-    if (text.length > MAX_CACHEABLE_TEXT_CHARACTERS) {
-        throw new RangeError(`${caller} path exceeds ${String(MAX_CACHEABLE_TEXT_CHARACTERS)} characters`);
-    }
-    if (!text.startsWith("$"))
-        throw new TypeError(`${caller} paths start at $`);
-    const steps = [];
-    let cursor = 1;
-    while (cursor < text.length) {
-        if (text[cursor] === ".") {
-            cursor += 1;
-            const start = cursor;
-            while (cursor < text.length && /[A-Za-z0-9_]/.test(text[cursor] ?? ""))
-                cursor += 1;
-            if (cursor === start)
-                throw new TypeError(`${caller} path expects a member name after .`);
-            steps.push({ kind: "member", name: text.slice(start, cursor), index: 0 });
-            continue;
-        }
-        if (text[cursor] === "[") {
-            const close = text.indexOf("]", cursor);
-            if (close === -1)
-                throw new TypeError(`${caller} path has an unclosed subscript`);
-            const inner = text.slice(cursor + 1, close).trim();
-            cursor = close + 1;
-            if (/^\d+$/.test(inner)) {
-                steps.push({ kind: "index", name: "", index: Number(inner) });
-                continue;
-            }
-            const quoted = /^'(.*)'$/.exec(inner) ?? /^"(.*)"$/.exec(inner);
-            if (quoted?.[1] !== undefined) {
-                steps.push({ kind: "member", name: quoted[1], index: 0 });
-                continue;
-            }
-            throw new TypeError(`${caller} paths take array indexes and member names, not: ${inner}`);
-        }
-        throw new TypeError(`${caller} path is not understood: ${text}`);
-    }
-    return steps;
+function parseJsonPath(path, caller) {
+  const text = stringArgument(caller, path).trim();
+  if (text.length > MAX_CACHEABLE_TEXT_CHARACTERS) {
+    throw new RangeError(`${caller} path exceeds ${String(MAX_CACHEABLE_TEXT_CHARACTERS)} characters`);
+  }
+  if (!text.startsWith("$"))
+    throw new TypeError(`${caller} paths start at $`);
+  const steps = [];
+  let cursor = 1;
+  while (cursor < text.length) {
+    if (text[cursor] === ".") {
+      cursor += 1;
+      const start = cursor;
+      while (cursor < text.length && /[A-Za-z0-9_]/.test(text[cursor] ?? ""))
+        cursor += 1;
+      if (cursor === start)
+        throw new TypeError(`${caller} path expects a member name after .`);
+      steps.push({ kind: "member", name: text.slice(start, cursor), index: 0 });
+      continue;
+    }
+    if (text[cursor] === "[") {
+      const close = text.indexOf("]", cursor);
+      if (close === -1)
+        throw new TypeError(`${caller} path has an unclosed subscript`);
+      const inner = text.slice(cursor + 1, close).trim();
+      cursor = close + 1;
+      if (/^\d+$/.test(inner)) {
+        steps.push({ kind: "index", name: "", index: Number(inner) });
+        continue;
+      }
+      const quoted = /^'(.*)'$/.exec(inner) ?? /^"(.*)"$/.exec(inner);
+      if (quoted?.[1] !== void 0) {
+        steps.push({ kind: "member", name: quoted[1], index: 0 });
+        continue;
+      }
+      throw new TypeError(`${caller} paths take array indexes and member names, not: ${inner}`);
+    }
+    throw new TypeError(`${caller} path is not understood: ${text}`);
+  }
+  return steps;
 }
-/** Walks one path over a document, reporting whether it selected anything. */
-export function jsonAtPath(document, path, caller) {
-    const steps = parseJsonPath(path, caller);
-    let current;
-    const source = boundedJsonDocument(document, caller);
-    try {
-        current = JSON.parse(source);
-    }
-    catch {
-        // A document that is not JSON selects nothing rather than failing the whole statement,
-        // matching the standard's default ON ERROR behaviour for these functions.
+function jsonAtPath(document, path, caller) {
+  const steps = parseJsonPath(path, caller);
+  let current;
+  const source = boundedJsonDocument(document, caller);
+  try {
+    current = JSON.parse(source);
+  } catch {
+    return { found: false };
+  }
+  for (const step of steps) {
+    if (current === null || current === void 0)
+      return { found: false };
+    if (step.kind === "index") {
+      if (!Array.isArray(current))
         return { found: false };
-    }
-    for (const step of steps) {
-        if (current === null || current === undefined)
-            return { found: false };
-        if (step.kind === "index") {
-            if (!Array.isArray(current))
-                return { found: false };
-            if (step.index >= current.length)
-                return { found: false };
-            current = current[step.index];
-            continue;
-        }
-        if (typeof current !== "object" || Array.isArray(current))
-            return { found: false };
-        const members = current;
-        if (!Object.hasOwn(members, step.name))
-            return { found: false };
-        current = members[step.name];
-    }
-    return { found: true, value: current };
+      if (step.index >= current.length)
+        return { found: false };
+      current = current[step.index];
+      continue;
+    }
+    if (typeof current !== "object" || Array.isArray(current))
+      return { found: false };
+    const members = current;
+    if (!Object.hasOwn(members, step.name))
+      return { found: false };
+    current = members[step.name];
+  }
+  return { found: true, value: current };
 }
-/**
- * One step of PostgreSQL's `->`/`->>` access. A text key selects an object member; an integer
- * key selects an array element, counting from the end when negative. The behaviour follows
- * PostgreSQL's `json` type: a document of the wrong shape for the key selects nothing (NULL)
- * rather than jsonb's scalar-as-one-element-array reading. Unlike the SQL/JSON functions, whose
- * standard ON ERROR default swallows malformed documents, PostgreSQL's operators only exist on
- * values already parsed as json, so a document that is not JSON is an error here.
- */
-export function jsonArrowStep(document, key, caller) {
-    const source = boundedJsonDocument(document, caller);
-    let parsed;
-    try {
-        parsed = JSON.parse(source);
-    }
-    catch {
-        throw new TypeError(`${caller} requires a JSON document`);
-    }
-    const step = externalSqlDomainValue(key);
-    if (typeof step === "number") {
-        if (!Number.isInteger(step)) {
-            throw new TypeError(`${caller} array positions are integers`);
-        }
-        if (!Array.isArray(parsed))
-            return { found: false };
-        const index = step < 0 ? parsed.length + step : step;
-        if (index < 0 || index >= parsed.length)
-            return { found: false };
-        return { found: true, value: parsed[index] };
-    }
-    if (typeof step === "string") {
-        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-            return { found: false };
-        }
-        const members = parsed;
-        if (!Object.hasOwn(members, step))
-            return { found: false };
-        return { found: true, value: members[step] };
-    }
-    throw new TypeError(`${caller} keys are member names or array positions`);
+function jsonArrowStep(document, key, caller) {
+  const source = boundedJsonDocument(document, caller);
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new TypeError(`${caller} requires a JSON document`);
+  }
+  const step = externalSqlDomainValue(key);
+  if (typeof step === "number") {
+    if (!Number.isInteger(step)) {
+      throw new TypeError(`${caller} array positions are integers`);
+    }
+    if (!Array.isArray(parsed))
+      return { found: false };
+    const index = step < 0 ? parsed.length + step : step;
+    if (index < 0 || index >= parsed.length)
+      return { found: false };
+    return { found: true, value: parsed[index] };
+  }
+  if (typeof step === "string") {
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { found: false };
+    }
+    const members = parsed;
+    if (!Object.hasOwn(members, step))
+      return { found: false };
+    return { found: true, value: members[step] };
+  }
+  throw new TypeError(`${caller} keys are member names or array positions`);
 }
-/** Whether a value is JSON text of the requested shape (T825). */
-export function jsonIsValid(document, kind) {
-    document = externalSqlDomainValue(document);
-    if (typeof document !== "string")
-        return false;
-    if (document.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`JSON document exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(document);
-    }
-    catch {
-        return false;
-    }
-    const isObject = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
-    switch (kind) {
-        case "object":
-            return isObject;
-        case "array":
-            return Array.isArray(parsed);
-        case "scalar":
-            return !isObject && !Array.isArray(parsed);
-        default:
-            return true;
-    }
+function jsonIsValid(document, kind) {
+  document = externalSqlDomainValue(document);
+  if (typeof document !== "string")
+    return false;
+  if (document.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`JSON document exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(document);
+  } catch {
+    return false;
+  }
+  const isObject = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+  switch (kind) {
+    case "object":
+      return isObject;
+    case "array":
+      return Array.isArray(parsed);
+    case "scalar":
+      return !isObject && !Array.isArray(parsed);
+    default:
+      return true;
+  }
 }
-/** A SQL value as its JSON counterpart: datetimes serialize as ISO text, like every cast. */
 function jsonValueOf(value) {
-    const external = externalSqlDomainValue(value);
-    return external instanceof Date ? dateIsoString(external) : external;
+  const external = externalSqlDomainValue(value);
+  return external instanceof Date ? dateIsoString(external) : external;
 }
-/**
- * JSON_ARRAY(v, ...) and JSON_OBJECT(k, v, ...) (T811/T812). The omitted null-handling clause is
- * `NULL ON NULL`: SQL NULL becomes a JSON null. `ABSENT ON NULL` is a separate spelling rather
- * than the default. Constructors return JSON text at the JavaScript boundary.
- */
-export function jsonConstructor(name, values) {
-    if (name === "JSON_ARRAY") {
-        const members = values.map((value) => boundedJsonValue(value ?? null, "JSON_ARRAY value"));
-        return joinBoundedJson("[", members, "]", "JSON_ARRAY result");
-    }
-    const members = [];
-    for (let index = 0; index + 1 < values.length; index += 2) {
-        const rawKey = externalSqlDomainValue(values[index]);
-        if (rawKey === null || rawKey === undefined) {
-            throw new TypeError("JSON_OBJECT keys cannot be NULL");
-        }
-        let key;
-        if (rawKey instanceof Date)
-            key = dateIsoString(rawKey);
-        else if (typeof rawKey === "string")
-            key = rawKey;
-        else if (typeof rawKey === "number" || typeof rawKey === "boolean")
-            key = String(rawKey);
-        else
-            throw new TypeError("JSON_OBJECT keys must be scalar values");
-        const member = values[index + 1];
-        // Build JSON text directly. WITHOUT UNIQUE KEYS is the default, so duplicate names must be
-        // preserved; assigning through a JavaScript object would collapse them and mishandle
-        // special names such as "__proto__".
-        // Keys are always JSON strings. In particular, a JSON-domain expression used as a key is
-        // its document text, not a raw object member token as JSON-domain values are below.
-        const encodedKey = boundedJsonString(key, "JSON_OBJECT key");
-        const encodedValue = boundedJsonValue(member ?? null, "JSON_OBJECT value");
-        members.push(`${encodedKey}:${encodedValue}`);
-    }
-    return joinBoundedJson("{", members, "}", "JSON_OBJECT result");
+function jsonConstructor(name, values) {
+  if (name === "JSON_ARRAY") {
+    const members2 = values.map((value) => boundedJsonValue(value ?? null, "JSON_ARRAY value"));
+    return joinBoundedJson("[", members2, "]", "JSON_ARRAY result");
+  }
+  const members = [];
+  for (let index = 0; index + 1 < values.length; index += 2) {
+    const rawKey = externalSqlDomainValue(values[index]);
+    if (rawKey === null || rawKey === void 0) {
+      throw new TypeError("JSON_OBJECT keys cannot be NULL");
+    }
+    let key;
+    if (rawKey instanceof Date)
+      key = dateIsoString(rawKey);
+    else if (typeof rawKey === "string")
+      key = rawKey;
+    else if (typeof rawKey === "number" || typeof rawKey === "boolean")
+      key = String(rawKey);
+    else
+      throw new TypeError("JSON_OBJECT keys must be scalar values");
+    const member = values[index + 1];
+    const encodedKey = boundedJsonString(key, "JSON_OBJECT key");
+    const encodedValue = boundedJsonValue(member ?? null, "JSON_OBJECT value");
+    members.push(`${encodedKey}:${encodedValue}`);
+  }
+  return joinBoundedJson("{", members, "}", "JSON_OBJECT result");
 }
 function boundedJsonString(value, label) {
-    if (value.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    const encoded = JSON.stringify(value);
-    if (encoded.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    return encoded;
+  if (value.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  const encoded = JSON.stringify(value);
+  if (encoded.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  return encoded;
 }
 function boundedJsonDocument(value, caller) {
-    const document = stringArgument(caller, externalSqlDomainValue(value));
-    if (document.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${caller} document exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    return document;
+  const document = stringArgument(caller, externalSqlDomainValue(value));
+  if (document.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${caller} document exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  return document;
 }
 function boundedJsonValue(value, label) {
-    const domainDocument = jsonDomainDocument(value);
-    if (domainDocument !== undefined) {
-        if (domainDocument.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-            throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-        }
-        return domainDocument;
-    }
-    const normalized = jsonValueOf(value);
-    if (typeof normalized === "string" && normalized.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    const encoded = JSON.stringify(normalized);
-    if (typeof encoded !== "string")
-        throw new TypeError(`${label} is not JSON serializable`);
-    if (encoded.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    return encoded;
+  const domainDocument = jsonDomainDocument(value);
+  if (domainDocument !== void 0) {
+    if (domainDocument.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+      throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+    }
+    return domainDocument;
+  }
+  const normalized = jsonValueOf(value);
+  if (typeof normalized === "string" && normalized.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  const encoded = JSON.stringify(normalized);
+  if (typeof encoded !== "string")
+    throw new TypeError(`${label} is not JSON serializable`);
+  if (encoded.length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  return encoded;
 }
 function joinBoundedJson(prefix, members, suffix, label) {
-    let length = prefix.length + suffix.length;
-    for (const member of members) {
-        length += member.length;
-        if (!Number.isSafeInteger(length) || length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-            throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-        }
-    }
-    if (members.length > 1)
-        length += members.length - 1;
+  let length = prefix.length + suffix.length;
+  for (const member of members) {
+    length += member.length;
     if (!Number.isSafeInteger(length) || length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
-        throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
-    }
-    return `${prefix}${members.join(",")}${suffix}`;
+      throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+    }
+  }
+  if (members.length > 1)
+    length += members.length - 1;
+  if (!Number.isSafeInteger(length) || length > MAX_SQL_SCALAR_RESULT_CHARACTERS) {
+    throw new RangeError(`${label} exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
+  }
+  return `${prefix}${members.join(",")}${suffix}`;
 }
 import { dateIsoString } from "../date-value.js";
+export {
+  jsonArrowStep,
+  jsonAtPath,
+  jsonConstructor,
+  jsonIsValid,
+  parseJsonPath
+};

package/dist/engine/sql-semantics.d.ts

@@ -1,9 +1,23 @@
 /**
- * SQL value semantics shared by the row and vector executors.
- *
- * Keep comparison, equality-key, scalar, and pattern behavior here so an execution-path
- * optimization cannot silently change query results.
+ * The standard's datetime text — `2026-01-02`, `2026-01-02 03:04:05`, `2026-01-02T03:04:05.250Z`,
+ * an optional zone offset — read as an instant. A zoneless spelling is UTC, the reading every
+ * datetime in a Minnow database has; `undefined` for text in any other shape.
  */
+export declare function parseSqlTimestampText(text: string): Date | undefined;
+/**
+ * PostgreSQL reads an untyped string constant beside a typed value in that value's type:
+ * `joined >= '2026-01-01'`, `id = '5'`, `active = 't'`. Catalog-backed plans coerce such literals
+ * before execution; this runtime reading covers the schema-less row executor and anything the
+ * plan rewrite could not see. Text that does not parse in the other side's type keeps the
+ * comparable-types error below, so a genuine mismatch still fails.
+ */
+export declare function coercedComparable(text: string, other: unknown): unknown;
+/**
+ * Applies the untyped-literal reading to a comparison's two operands: a plain string beside a
+ * typed value (datetime, DATE, number, boolean) is read in that value's type when it parses.
+ * Both executors call this before their own comparisons, so the reading is one decision.
+ */
+export declare function coerceComparisonOperands(left: unknown, right: unknown): [unknown, unknown];
 /**
  * Deterministic SQL ordering. Strings use Unicode codepoint order rather than host locale data,
  * and signed zero compares equal because SQL numeric equality does not distinguish it.
@@ -24,6 +38,13 @@ interface SqlPatternMatcher {
 }
 /** Compiles SQL LIKE without exposing input to the host regular-expression engine. */
 export declare function compileLikePattern(pattern: string, caseInsensitive?: boolean, escape?: string): SqlPatternMatcher;
+/**
+ * PostgreSQL's ~ / ~* / !~ / !~* operators and REGEXP_REPLACE, compiled as JavaScript regular
+ * expressions. Advanced regular expressions and JavaScript agree on the everyday syntax; the
+ * `n` flag makes `.` and anchors newline-sensitive, `i` is case-insensitive, and `g` replaces
+ * every match. Patterns are bounded like every other SQL pattern.
+ */
+export declare function compileRegexPattern(pattern: string, flags?: string): RegExp;
 /** PostgreSQL SIMILAR TO compiled to a Thompson NFA with bounded deterministic work. */
 export declare function compileSimilarPattern(pattern: string, escape?: string): SqlPatternMatcher;
 /** Defines an own enumerable result-column property, including the special name `__proto__`. */