envio 3.15.0 → 3.16.0

package/src/StagedRows.res

@@ -0,0 +1,106 @@
+// Values as the addon declares each staged field has to arrive, compiled once
+// per layout and written into a stage.
+
+@send external getTime: unknown => float = "getTime"
+@send external toFixed: unknown => string = "toFixed"
+@val @scope("Array") external isArray: unknown => bool = "isArray"
+
+// A list element as its JSON: the encoding a scalar of its type would take,
+// except that a boolean stays one and bytes become their values.
+%%private(
+  let elementOf = (encoding: Staging.encoding, ~column): (unknown => unknown) =>
+    switch encoding {
+    | Number =>
+      value =>
+        value->Staging.toNumber->Staging.finiteOrThrow(~column)->(Utils.magic: float => unknown)
+    | Date => value => value->getTime->(Utils.magic: float => unknown)
+    | Digits => value => value->Staging.stringOf->(Utils.magic: string => unknown)
+    | Decimal => value => value->toFixed->(Utils.magic: string => unknown)
+    | Document => value => value->Sql.canonicalDocument->(Utils.magic: string => unknown)
+    | Bytes =>
+      value =>
+        value
+        ->(Utils.magic: unknown => Array.arrayLike<int>)
+        ->Array.fromArrayLike
+        ->(Utils.magic: array<int> => unknown)
+    | Bool | Text | List => value => value
+    }
+)
+
+%%private(
+  let rec mapList = (value: unknown, element: unknown => unknown): unknown =>
+    if value->isArray {
+      value
+      ->(Utils.magic: unknown => array<unknown>)
+      ->Array.map(item => item->mapList(element))
+      ->(Utils.magic: array<unknown> => unknown)
+    } else if value === %raw(`undefined`) || value === %raw(`null`) {
+      %raw(`null`)
+    } else {
+      element(value)
+    }
+)
+
+// What a present value becomes before it is written to its slot.
+%%private(
+  let encoderOf = ({name, encoding, element}: Staging.stagedField): (unknown => unknown) =>
+    switch encoding {
+    | Bool =>
+      value => (value->(Utils.magic: unknown => bool) ? 1. : 0.)->(Utils.magic: float => unknown)
+    | Date => value => value->getTime->(Utils.magic: float => unknown)
+    | Decimal => value => value->toFixed->(Utils.magic: string => unknown)
+    | Document => value => value->Sql.canonicalDocument->(Utils.magic: string => unknown)
+    | List =>
+      let encode = elementOf(element, ~column=name)
+      // A document can be a list itself, so a list of them is one level deep.
+      let mapList = switch element {
+      | Document =>
+        (value, encode) =>
+          value
+          ->(Utils.magic: unknown => array<unknown>)
+          ->Array.map(item => item->Staging.isAbsent ? %raw(`null`) : encode(item))
+          ->(Utils.magic: array<unknown> => unknown)
+      | _ => mapList
+      }
+      value =>
+        value
+        ->mapList(encode)
+        ->(Utils.magic: unknown => JSON.t)
+        ->JSON.stringify
+        ->Utils.replaceLoneSurrogateEscapes
+        ->(Utils.magic: string => unknown)
+    | Number | Text | Digits | Bytes => value => value
+    }
+)
+
+// A layout's fields compiled once: the slot each takes and how a value of it
+// is written there.
+type writer = {field: Staging.stagedField, encode: unknown => unknown}
+
+let writersOf = (fields: array<Staging.stagedField>) =>
+  fields->Array.map(field => {field, encode: encoderOf(field)})
+
+let columnsOf = (writers: array<writer>): array<Staging.column> =>
+  writers->Array.map(({field}) => {
+    Staging.name: field.name,
+    kind: field.encoding->Staging.kindOf,
+    isNullable: field.isNullable,
+  })
+
+// JSON `null` is a document of its own, which a column that can't be NULL
+// stores as one. Left out, the value is no document and is refused like any
+// other.
+let writeField = (stage, ~writers: array<writer>, ~column, ~row, value: unknown) => {
+  let {field, encode} = writers->Array.getUnsafe(column)
+  if value->Staging.isAbsent {
+    stage->Staging.writeValue(
+      ~column,
+      ~row,
+      field.encoding === Staging.Document && !field.isNullable && value === %raw(`null`)
+        ? "null"->(Utils.magic: string => unknown)
+        : value,
+    )
+  } else {
+    stage->Staging.writeValue(~column, ~row, encode(value))
+  }
+}

package/src/StagedRows.res.mjs

@@ -0,0 +1,102 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sql from "./db/Sql.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Staging from "./Staging.res.mjs";
+
+function elementOf(encoding, column) {
+  switch (encoding) {
+    case "Number" :
+      return value => Staging.finiteOrThrow(Number(value), column);
+    case "Date" :
+      return value => value.getTime();
+    case "Digits" :
+      return value => String(value);
+    case "Decimal" :
+      return value => value.toFixed();
+    case "Document" :
+      return Sql.canonicalDocument;
+    case "Bytes" :
+      return value => Array.from(value);
+    default:
+      return value => value;
+  }
+}
+
+function mapList(value, element) {
+  if (Array.isArray(value)) {
+    return value.map(item => mapList(item, element));
+  } else if (value === undefined || value === null) {
+    return null;
+  } else {
+    return element(value);
+  }
+}
+
+function encoderOf(param) {
+  let element = param.element;
+  switch (param.encoding) {
+    case "Bool" :
+      return value => {
+        if (value) {
+          return 1;
+        } else {
+          return 0;
+        }
+      };
+    case "Date" :
+      return value => value.getTime();
+    case "Decimal" :
+      return value => value.toFixed();
+    case "Document" :
+      return Sql.canonicalDocument;
+    case "List" :
+      let encode = elementOf(element, param.name);
+      let mapList$1;
+      mapList$1 = element === "Document" ? (value, encode) => value.map(item => {
+          if (Staging.isAbsent(item)) {
+            return null;
+          } else {
+            return encode(item);
+          }
+        }) : mapList;
+      return value => Utils.replaceLoneSurrogateEscapes(JSON.stringify(mapList$1(value, encode)));
+    default:
+      return value => value;
+  }
+}
+
+function writersOf(fields) {
+  return fields.map(field => ({
+    field: field,
+    encode: encoderOf(field)
+  }));
+}
+
+function columnsOf(writers) {
+  return writers.map(param => {
+    let field = param.field;
+    return {
+      name: field.name,
+      kind: Staging.kindOf(field.encoding),
+      isNullable: field.isNullable
+    };
+  });
+}
+
+function writeField(stage, writers, column, row, value) {
+  let match = writers[column];
+  let field = match.field;
+  if (Staging.isAbsent(value)) {
+    return Staging.writeValue(stage, column, row, field.encoding === "Document" && !field.isNullable && value === null ? "null" : value);
+  } else {
+    return Staging.writeValue(stage, column, row, match.encode(value));
+  }
+}
+
+export {
+  writersOf,
+  columnsOf,
+  writeField,
+}
+/* Sql Not a pure module */

package/src/Staging.res

@@ -10,16 +10,6 @@ type kind =
   | @as(3) Text
   | @as(4) Bytes
 
-let kindOfOrdinal = ordinal =>
-  switch ordinal {
-  | 0 => F64
-  | 1 => U64
-  | 2 => I64
-  | 3 => Text
-  | 4 => Bytes
-  | unknown => JsError.throwWithMessage(`Unknown staged column kind ${unknown->Int.toString}`)
-  }
-
 // The replacer closes over nothing but the column's name, so it is built once
 // with the column rather than once per column per batch.
 type column = {name: string, kind: kind, isNullable: bool, replacer?: JSON.replacer}
@@ -28,7 +18,7 @@ type begun = {handle: int, buffers: array<ArrayBuffer.t>}
 
 // What the addon exposes, so this module stays free of the storage's own API.
 type arena = {
-  beginStage: (~table: int, ~rows: int) => begun,
+  beginStage: (~rows: int) => begun,
   growStage: (~handle: int, ~column: int, ~needed: int, ~stale: ArrayBuffer.t) => ArrayBuffer.t,
   commitStage: (~handle: int, ~buffers: array<ArrayBuffer.t>) => unit,
   abortStage: (~handle: int, ~buffers: array<ArrayBuffer.t>) => unit,
@@ -79,8 +69,8 @@ type t = {
   builders: array<builder>,
 }
 
-let begin = (arena, ~table, ~rows, ~columns: array<column>) => {
-  let {handle, buffers} = arena.beginStage(~table, ~rows)
+let begin = (arena, ~rows, ~columns: array<column>) => {
+  let {handle, buffers} = arena.beginStage(~rows)
   let slot = ref(0)
   let take = () => {
     let buffer = buffers->Array.getUnsafe(slot.contents)
@@ -275,7 +265,7 @@ let toText = (value: unknown, ~replacer=?) =>
     }
 )
 
-%%private(let isAbsent = (value: unknown) => value === %raw(`undefined`) || value === %raw(`null`))
+let isAbsent = (value: unknown) => value === %raw(`undefined`) || value === %raw(`null`)
 
 // Writes one value of a row the handler set. `undefined`/`null` marks the row's
 // null bit, which a column that accepts NULL stores as such — and which one that
@@ -317,3 +307,31 @@ let commit = stage => {
 }
 
 let abort = stage => stage.arena.abortStage(~handle=stage.handle, ~buffers=stage.buffers)
+
+// How a staged value has to arrive, as the addon declares it for every field:
+// `storage::schema::Encoding`.
+type encoding =
+  | Number
+  | Bool
+  | Date
+  | Text
+  | Digits
+  | Decimal
+  | Document
+  | Bytes
+  | List
+
+type stagedField = {
+  name: string,
+  encoding: encoding,
+  // What a list's elements are encoded as; the field's own for a scalar.
+  element: encoding,
+  isNullable: bool,
+}
+
+let kindOf = (encoding: encoding) =>
+  switch encoding {
+  | Number | Bool | Date => F64
+  | Text | Digits | Decimal | Document | List => Text
+  | Bytes => Bytes
+  }

package/src/Staging.res.mjs

@@ -4,27 +4,10 @@ import * as Utils from "./Utils.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
-function kindOfOrdinal(ordinal) {
-  switch (ordinal) {
-    case 0 :
-      return 0;
-    case 1 :
-      return 1;
-    case 2 :
-      return 2;
-    case 3 :
-      return 3;
-    case 4 :
-      return 4;
-    default:
-      return Stdlib_JsError.throwWithMessage(`Unknown staged column kind ` + ordinal.toString());
-  }
-}
-
 let encoder = new TextEncoder();
 
-function begin(arena, table, rows, columns) {
-  let match = arena.beginStage(table, rows);
+function begin(arena, rows, columns) {
+  let match = arena.beginStage(rows);
   let buffers = match.buffers;
   let slot = {
     contents: 0
@@ -249,15 +232,29 @@ function abort(stage) {
   stage.arena.abortStage(stage.handle, stage.buffers);
 }
 
+function kindOf(encoding) {
+  switch (encoding) {
+    case "Number" :
+    case "Bool" :
+    case "Date" :
+      return 0;
+    case "Bytes" :
+      return 4;
+    default:
+      return 3;
+  }
+}
+
 export {
-  kindOfOrdinal,
   begin,
   finiteOrThrow,
   toText,
+  isAbsent,
   writeValue,
   writeDeletedValue,
   columnCount,
   commit,
   abort,
+  kindOf,
 }
 /* encoder Not a pure module */