@reifydb/core 0.9.1 → 0.9.3

package/dist/index.js

@@ -1,5 +1,20 @@
 // src/constant.ts
 var NONE_VALUE = "\u27EAnone\u27EB";
+var NONE_MARKER_OPEN = NONE_VALUE.slice(0, -1);
+var NONE_MARKER_CLOSE = NONE_VALUE.slice(-1);
+function noneMarker(depth) {
+  return depth === 0 ? NONE_VALUE : `${NONE_MARKER_OPEN}:${depth}${NONE_MARKER_CLOSE}`;
+}
+function noneMarkerDepth(payload) {
+  if (payload === NONE_VALUE) {
+    return 0;
+  }
+  if (!payload.startsWith(`${NONE_MARKER_OPEN}:`) || !payload.endsWith(NONE_MARKER_CLOSE)) {
+    return void 0;
+  }
+  const digits = payload.slice(NONE_MARKER_OPEN.length + 1, -NONE_MARKER_CLOSE.length);
+  return /^[1-9][0-9]*$/.test(digits) ? Number(digits) : void 0;
+}
 var ROW_NUMBER_KEY = "#rownum";
 
 // src/value/blob.ts
@@ -2286,11 +2301,151 @@ var NoneValue = class _NoneValue {
   }
   encode() {
     return {
-      type: "None",
+      type: { Option: this.innerType },
       value: NONE_VALUE
     };
   }
 };
+function noneDepth(v) {
+  return optionDepth(v.innerType) + 1;
+}
+
+// src/present/value.ts
+var NONE_PRESENTATION = {
+  text: "none",
+  italic: true,
+  muted: true
+};
+var ROLE_BY_TYPE = {
+  None: "none",
+  Boolean: "boolean",
+  Int1: "number",
+  Int2: "number",
+  Int4: "number",
+  Int8: "number",
+  Int16: "number",
+  Uint1: "number",
+  Uint2: "number",
+  Uint4: "number",
+  Uint8: "number",
+  Uint16: "number",
+  Float4: "number",
+  Float8: "number",
+  Decimal: "number",
+  Date: "temporal",
+  DateTime: "temporal",
+  Time: "temporal",
+  Duration: "temporal",
+  Uuid4: "uuid",
+  Uuid7: "uuid",
+  IdentityId: "uuid",
+  Utf8: "string",
+  Blob: "blob"
+};
+function typeName(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const candidate = value.type;
+  return typeof candidate === "string" ? candidate : void 0;
+}
+function valueTypeName(value) {
+  if (value === null || value === void 0) return "None";
+  return typeName(value);
+}
+function valueRole(value) {
+  if (value === null || value === void 0) return "none";
+  const name = typeName(value);
+  if (name !== void 0) {
+    return ROLE_BY_TYPE[name] ?? "unknown";
+  }
+  switch (typeof value) {
+    case "number":
+    case "bigint":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    default:
+      return "unknown";
+  }
+}
+function formatValue(value) {
+  if (value === null || value === void 0) return NONE_PRESENTATION.text;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object") {
+    const name = typeName(value);
+    if (name === "None") return NONE_PRESENTATION.text;
+    if (name !== void 0) return String(value);
+    return JSON.stringify(value) ?? String(value);
+  }
+  return String(value);
+}
+
+// src/value/option.ts
+function describeType(t) {
+  return isOptionType(t) ? `Option(${describeType(t.Option)})` : t;
+}
+function hasType(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function hasToJSON(value) {
+  return typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function";
+}
+var OPTION_BRAND = /* @__PURE__ */ Symbol.for("reifydb.option");
+function isOption(value) {
+  return typeof value === "object" && value !== null && value[OPTION_BRAND] === true;
+}
+var _a;
+_a = OPTION_BRAND;
+var _Option = class _Option {
+  constructor(state) {
+    this.state = state;
+    this[_a] = true;
+  }
+  static some(value) {
+    return new _Option({ some: true, value });
+  }
+  static none(inner) {
+    return new _Option({ some: false, inner });
+  }
+  isSome() {
+    return this.state.some;
+  }
+  isNone() {
+    return !this.state.some;
+  }
+  unwrap() {
+    if (this.state.some) {
+      return this.state.value;
+    }
+    throw new Error(`unwrap on a None of type ${describeType(this.state.inner)}`);
+  }
+  unwrapOr(fallback) {
+    return this.state.some ? this.state.value : fallback;
+  }
+  map(fn) {
+    return this.state.some ? _Option.some(fn(this.state.value)) : _Option.none(this.state.inner);
+  }
+  get type() {
+    if (!this.state.some) {
+      return { Option: this.state.inner };
+    }
+    if (hasType(this.state.value)) {
+      return { Option: this.state.value.type };
+    }
+    throw new Error(`Option.some over a raw ${typeof this.state.value} has no wire type`);
+  }
+  toString() {
+    return this.state.some ? String(this.state.value) : NONE_PRESENTATION.text;
+  }
+  toJSON() {
+    if (!this.state.some) {
+      return null;
+    }
+    return hasToJSON(this.state.value) ? this.state.value.toJSON() : this.state.value;
+  }
+};
+var Option = _Option;
 
 // src/value/utf8.ts
 var Utf8Value = class _Utf8Value {
@@ -2746,6 +2901,49 @@ var IdentityIdValue = class _IdentityIdValue {
   }
 };
 
+// src/value/wire-type.ts
+function typeToWire(type) {
+  return isOptionType(type) ? { id: "Option", underlying: typeToWire(type.Option) } : { id: type };
+}
+function typeFromWire(wire) {
+  if (!wire || typeof wire !== "object" || typeof wire.id !== "string") {
+    throw new Error(`Expected a type descriptor object, got ${JSON.stringify(wire)}`);
+  }
+  if (wire.id === "Option") {
+    if (!wire.underlying) {
+      throw new Error("Option type descriptor is missing its underlying type");
+    }
+    return { Option: typeFromWire(wire.underlying) };
+  }
+  return wire.id;
+}
+function columnsFromWire(columns) {
+  return columns.map((column) => ({ ...column, type: typeFromWire(column.type) }));
+}
+function framesFromWire(frames) {
+  return frames.map(
+    (frame) => frame && frame.columns ? { ...frame, columns: columnsFromWire(frame.columns) } : frame
+  );
+}
+function envelopeToColumns(envelope) {
+  const types = envelope?.types ?? {};
+  const rows = envelope?.rows ?? [];
+  return Object.keys(types).map((name) => ({
+    name,
+    type: typeFromWire(types[name]),
+    payload: rows.map((row) => payloadOf(row?.[name]))
+  }));
+}
+function envelopesToFrames(envelopes) {
+  return Array.isArray(envelopes) ? envelopes.map((envelope) => ({ columns: envelopeToColumns(envelope) })) : [];
+}
+function payloadOf(value) {
+  if (value === null || value === void 0) {
+    return NONE_VALUE;
+  }
+  return typeof value === "string" ? value : String(value);
+}
+
 // src/value/index.ts
 function isOptionType(t) {
   return typeof t === "object" && t !== null && "Option" in t;
@@ -2754,17 +2952,30 @@ function unwrapOptionType(t) {
   if (isOptionType(t)) return unwrapOptionType(t.Option);
   return t;
 }
-var Value = class {
+function optionDepth(t) {
+  return isOptionType(t) ? optionDepth(t.Option) + 1 : 0;
+}
+function innerOfOption(t) {
+  return t.Option;
+}
+var Value2 = class {
 };
 
 // src/decoder.ts
+function stripOptionLayers(type, layers) {
+  return layers === 0 || !isOptionType(type) ? type : stripOptionLayers(innerOfOption(type), layers - 1);
+}
 function decode(pair) {
   if (isOptionType(pair.type)) {
-    const innerType = unwrapOptionType(pair.type);
-    if (pair.value === NONE_VALUE || pair.value === "") {
-      return new NoneValue(innerType);
+    const noneAt = noneMarkerDepth(pair.value);
+    if (noneAt === void 0) {
+      return decode({ type: unwrapOptionType(pair.type), value: pair.value });
+    }
+    const depth = optionDepth(pair.type);
+    if (noneAt >= depth) {
+      throw new Error(`none under ${noneAt} Some layers cannot fit an option of depth ${depth}`);
     }
-    return decode({ type: innerType, value: pair.value });
+    return new NoneValue(stripOptionLayers(pair.type, noneAt + 1));
   }
   switch (pair.type) {
     case "Blob":
@@ -2831,9 +3042,23 @@ function columnsToRows(columns) {
 }
 
 // src/encoder.ts
-function encodeValue(value) {
+function encodeValue(value, name = "$1") {
   if (value === null || value === void 0) {
-    return { type: "None", value: NONE_VALUE };
+    throw new Error(`parameter ${name} is null or undefined, use Option.none(inner)`);
+  }
+  if (value instanceof NoneValue && value.innerType === "None") {
+    throw new Error(`parameter ${name} is a NoneValue without an inner type, use Option.none(inner)`);
+  }
+  if (isOption(value)) {
+    if (value.isNone()) {
+      return { type: value.type, value: NONE_VALUE };
+    }
+    const inner = encodeValue(value.unwrap(), name);
+    const noneAt = noneMarkerDepth(inner.value);
+    return {
+      type: { Option: inner.type },
+      value: noneAt === void 0 ? inner.value : noneMarker(noneAt + 1)
+    };
   }
   if (value && typeof value === "object" && "encode" in value && typeof value.encode === "function") {
     return value.encode();
@@ -2902,16 +3127,19 @@ function encodeValue(value) {
   }
   throw new Error(`Cannot encode value of type ${typeof value}: ${value}`);
 }
+function toWire(pair) {
+  return { type: typeToWire(pair.type), value: pair.value };
+}
 function encodeParams(params) {
   if (params === void 0 || params === null) {
     return [];
   }
   if (Array.isArray(params)) {
-    return params.map((param) => encodeValue(param));
+    return params.map((param, i) => toWire(encodeValue(param, `$${i + 1}`)));
   } else if (typeof params === "object") {
     const encoded = {};
     for (const [key, value] of Object.entries(params)) {
-      encoded[key] = encodeValue(value);
+      encoded[key] = toWire(encodeValue(value, `$${key}`));
     }
     return encoded;
   }
@@ -3063,8 +3291,8 @@ var ShapeBuilder = class {
   static array(items) {
     return { kind: "array", items };
   }
-  static optional(shape) {
-    return { kind: "optional", shape };
+  static option(inner) {
+    return { kind: "option", inner };
   }
   static number() {
     return { kind: "primitive", type: "Float8" };
@@ -3222,11 +3450,14 @@ function parseValue(shape, value) {
     }
     return value.map((item) => parseValue(shape.items, item));
   }
-  if (shape.kind === "optional") {
-    if (value === void 0) {
+  if (shape.kind === "option") {
+    if (value === null || value === void 0) {
       return void 0;
     }
-    return parseValue(shape.shape, value);
+    if (isOption(value)) {
+      return value.map((item) => parseValue(shape.inner, item));
+    }
+    return Option.some(parseValue(shape.inner, value));
   }
   if (shape.kind === "value") {
     if (value === null || value === void 0) {
@@ -3296,11 +3527,11 @@ function validateShape(shape, value) {
     }
     return value.every((item) => validateShape(shape.items, item));
   }
-  if (shape.kind === "optional") {
-    if (value === void 0) {
-      return true;
+  if (shape.kind === "option") {
+    if (!isOption(value)) {
+      return false;
     }
-    return validateShape(shape.shape, value);
+    return value.isNone() || validateShape(shape.inner, value.unwrap());
   }
   if (shape.kind === "value") {
     if (value === null || value === void 0) {
@@ -3314,6 +3545,130 @@ function validateShape(shape, value) {
   return false;
 }
 
+// src/shape/widen.ts
+var NUMERIC = {
+  Int1: { kind: "int", bits: 8 },
+  Int2: { kind: "int", bits: 16 },
+  Int4: { kind: "int", bits: 32 },
+  Int8: { kind: "int", bits: 64 },
+  Int16: { kind: "int", bits: 128 },
+  Uint1: { kind: "uint", bits: 8 },
+  Uint2: { kind: "uint", bits: 16 },
+  Uint4: { kind: "uint", bits: 32 },
+  Uint8: { kind: "uint", bits: 64 },
+  Uint16: { kind: "uint", bits: 128 },
+  Float4: { kind: "float", bits: 32 },
+  Float8: { kind: "float", bits: 64 }
+};
+function widens(target, actual) {
+  if (isOptionType(actual)) {
+    return false;
+  }
+  const t = NUMERIC[target];
+  const a = NUMERIC[actual];
+  if (!t || !a) {
+    return target === actual;
+  }
+  if (t.kind === "float" || a.kind === "float") {
+    return t.kind === "float" && a.kind === "float" && t.bits >= a.bits;
+  }
+  if (t.kind === "uint") {
+    return a.kind === "uint" && t.bits >= a.bits;
+  }
+  return a.kind === "int" ? t.bits >= a.bits : t.bits > a.bits;
+}
+function widen(value, target) {
+  if (!value || typeof value !== "object" || typeof value.type !== "string") {
+    return value;
+  }
+  const actual = value.type;
+  if (actual === target || !widens(target, actual)) {
+    return value;
+  }
+  const inner = value.value;
+  if (inner === void 0 || inner === null) {
+    return value;
+  }
+  return decode({ type: target, value: String(inner) });
+}
+
+// src/shape/check.ts
+var ShapeMismatch = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ShapeMismatch";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function checkFrames(frames, shapes) {
+  if (shapes.length === 0) {
+    return;
+  }
+  if (frames.length !== shapes.length) {
+    throw new ShapeMismatch(`expected ${shapes.length} frames for ${shapes.length} shapes, got ${frames.length}`);
+  }
+  frames.forEach((frame, i) => checkFrame(frame.columns, shapes[i]));
+}
+function checkFrame(columns, shape) {
+  if (shape.kind !== "object") {
+    throw new ShapeMismatch(`a frame needs an object shape, got ${shape.kind}`);
+  }
+  for (const [name, propertyShape] of Object.entries(shape.properties)) {
+    const column = columns.find((c) => c.name === name);
+    if (!column) {
+      throw new ShapeMismatch(`column "${name}": expected ${describe(propertyShape)}, missing from frame`);
+    }
+    if (!matches(propertyShape, column.type)) {
+      throw new ShapeMismatch(`column "${name}": expected ${describe(propertyShape)}, got ${typeName2(column.type)}`);
+    }
+  }
+}
+var FAMILIES = [
+  ["Boolean"],
+  ["Int1", "Int2", "Int4", "Int8", "Int16", "Uint1", "Uint2", "Uint4", "Uint8", "Uint16", "Float4", "Float8"],
+  ["Utf8", "Decimal", "Duration", "Uuid4", "Uuid7", "IdentityId"],
+  ["Date", "DateTime", "Time"],
+  ["Blob"],
+  ["None"]
+];
+function familyOf(type) {
+  return FAMILIES.find((family) => family.includes(type)) ?? [type];
+}
+function matches(shape, type) {
+  switch (shape.kind) {
+    case "primitive":
+      if (shape.type === "None") {
+        return type === "None" || isOptionType(type);
+      }
+      return !isOptionType(type) && familyOf(shape.type).includes(type);
+    case "value":
+      if (shape.type === "None") {
+        return type === "None" || isOptionType(type);
+      }
+      return type === shape.type || widens(shape.type, type);
+    case "option":
+      return isOptionType(type) && matches(shape.inner, type.Option);
+    case "object":
+    case "array":
+      return false;
+  }
+}
+function describe(shape) {
+  switch (shape.kind) {
+    case "primitive":
+    case "value":
+      return shape.type;
+    case "option":
+      return `Option(${describe(shape.inner)})`;
+    case "object":
+    case "array":
+      return shape.kind;
+  }
+}
+function typeName2(type) {
+  return isOptionType(type) ? `Option(${typeName2(type.Option)})` : type;
+}
+
 // src/shape/transform.ts
 function snakeToCamel(key) {
   return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
@@ -3342,7 +3697,7 @@ function transformResult(row, resultShape) {
           transformedRow[outputKey] = coerceToPrimitiveType(value, propertyShape.type);
         }
       } else if (propertyShape && propertyShape.kind === "value") {
-        transformedRow[outputKey] = value;
+        transformedRow[outputKey] = widen(value, propertyShape.type);
       } else {
         transformedRow[outputKey] = propertyShape ? transformResult(value, propertyShape) : value;
       }
@@ -3356,7 +3711,7 @@ function transformResult(row, resultShape) {
     return coerceToPrimitiveType(row, resultShape.type);
   }
   if (resultShape && resultShape.kind === "value") {
-    return row;
+    return widen(row, resultShape.type);
   }
   if (resultShape && resultShape.kind === "array") {
     if (Array.isArray(row)) {
@@ -3364,17 +3719,24 @@ function transformResult(row, resultShape) {
     }
     return row;
   }
-  if (resultShape && resultShape.kind === "optional") {
-    if (row === void 0) {
-      return void 0;
-    }
-    if (row === null) {
-      return null;
+  if (resultShape && resultShape.kind === "option") {
+    if (row instanceof NoneValue) {
+      const remaining = optionLayers(resultShape);
+      const depth = noneDepth(row);
+      if (depth > remaining) {
+        throw new ShapeMismatch(`a none ${depth} layers deep does not fit a shape with ${remaining} option layers`);
+      }
+      if (depth === remaining) {
+        return Option.none(row.innerType);
+      }
     }
-    return transformResult(row, resultShape.shape);
+    return Option.some(transformResult(row, resultShape.inner));
   }
   return row;
 }
+function optionLayers(shape) {
+  return shape.kind === "option" ? optionLayers(shape.inner) + 1 : 0;
+}
 function coerceToPrimitiveType(value, valueType) {
   if (value === void 0 || value === null) {
     return value;
@@ -3394,77 +3756,6 @@ function coerceToPrimitiveType(value, valueType) {
   return value;
 }
 
-// src/present/value.ts
-var NONE_PRESENTATION = {
-  text: "none",
-  italic: true,
-  muted: true
-};
-var ROLE_BY_TYPE = {
-  None: "none",
-  Boolean: "boolean",
-  Int1: "number",
-  Int2: "number",
-  Int4: "number",
-  Int8: "number",
-  Int16: "number",
-  Uint1: "number",
-  Uint2: "number",
-  Uint4: "number",
-  Uint8: "number",
-  Uint16: "number",
-  Float4: "number",
-  Float8: "number",
-  Decimal: "number",
-  Date: "temporal",
-  DateTime: "temporal",
-  Time: "temporal",
-  Duration: "temporal",
-  Uuid4: "uuid",
-  Uuid7: "uuid",
-  IdentityId: "uuid",
-  Utf8: "string",
-  Blob: "blob"
-};
-function typeName(value) {
-  if (value === null || typeof value !== "object") return void 0;
-  const candidate = value.type;
-  return typeof candidate === "string" ? candidate : void 0;
-}
-function valueTypeName(value) {
-  if (value === null || value === void 0) return "None";
-  return typeName(value);
-}
-function valueRole(value) {
-  if (value === null || value === void 0) return "none";
-  const name = typeName(value);
-  if (name !== void 0) {
-    return ROLE_BY_TYPE[name] ?? "unknown";
-  }
-  switch (typeof value) {
-    case "number":
-    case "bigint":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "string":
-      return "string";
-    default:
-      return "unknown";
-  }
-}
-function formatValue(value) {
-  if (value === null || value === void 0) return NONE_PRESENTATION.text;
-  if (typeof value === "bigint") return value.toString();
-  if (typeof value === "object") {
-    const name = typeName(value);
-    if (name === "None") return NONE_PRESENTATION.text;
-    if (name !== void 0) return String(value);
-    return JSON.stringify(value) ?? String(value);
-  }
-  return String(value);
-}
-
 // src/present/width.ts
 var ZERO_WIDTH = [
   [768, 879],
@@ -3794,7 +4085,7 @@ var UNSIGNED_INTEGERS = ["uint1", "uint2", "uint4", "uint8", "uint16", "uint"];
 var FLOATING_POINT = ["float4", "float8"];
 var TEXT_AND_BINARY = ["utf8", "blob", "text"];
 var BOOLEAN = ["bool", "boolean"];
-var NUMERIC = ["decimal"];
+var NUMERIC2 = ["decimal"];
 var TEMPORAL = ["date", "datetime", "time", "duration", "interval"];
 var IDENTIFIERS_AND_UUIDS = [
   "uuid4",
@@ -3811,7 +4102,7 @@ var RQL_TYPES = [
   ...FLOATING_POINT,
   ...TEXT_AND_BINARY,
   ...BOOLEAN,
-  ...NUMERIC,
+  ...NUMERIC2,
   ...TEMPORAL,
   ...IDENTIFIERS_AND_UUIDS,
   ...CONTAINERS,
@@ -4049,6 +4340,7 @@ export {
   NONE_PRESENTATION,
   NONE_VALUE,
   NoneValue,
+  Option,
   ROW_NUMBER_KEY,
   RQL_KEYWORDS,
   RQL_LITERALS,
@@ -4058,6 +4350,7 @@ export {
   ReifyError,
   Shape,
   ShapeBuilder,
+  ShapeMismatch,
   TYPE_CODE,
   TimeValue,
   Uint16Value,
@@ -4068,18 +4361,30 @@ export {
   Utf8Value,
   Uuid4Value,
   Uuid7Value,
-  Value,
+  Value2 as Value,
   asFrameResults,
   cellText,
+  checkFrame,
+  checkFrames,
+  columnsFromWire,
   columnsToRows,
   decode,
   displayWidth,
   encodeParams,
   encodeValue,
+  envelopeToColumns,
+  envelopesToFrames,
   formatValue,
+  framesFromWire,
   graphemeWidth,
   inferColumns,
+  innerOfOption,
+  isOption,
   isOptionType,
+  noneDepth,
+  noneMarker,
+  noneMarkerDepth,
+  optionDepth,
   padToWidth,
   parseValue,
   planTable,
@@ -4087,7 +4392,9 @@ export {
   transformFrames,
   transformResult,
   truncateToWidth,
+  typeFromWire,
   typeNameFromCode,
+  typeToWire,
   unwrapOptionType,
   validateShape,
   valueRole,