envio 3.15.0-subgraph → 3.16.0-subgraph

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 */