envio 3.5.0-alpha.2 → 3.5.0-alpha.3

package/src/db/IndexRegistry.res.mjs

@@ -0,0 +1,195 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+function fromIndexFields(indexFields) {
+  return indexFields.map(param => ({
+    name: param.fieldName,
+    direction: param.direction
+  }));
+}
+
+function makeKey(tableName, columns, method) {
+  return tableName + `|` + method + `|` + columns.map(param => {
+    let name = param.name;
+    if (param.direction === "Asc") {
+      return name;
+    } else {
+      return name + " DESC";
+    }
+  }).join(",");
+}
+
+let catalogRowsSchema = S$RescriptSchema.array(S$RescriptSchema.object(s => ({
+  tableName: s.f("tableName", S$RescriptSchema.string),
+  indexName: s.f("indexName", S$RescriptSchema.string),
+  method: s.f("method", S$RescriptSchema.string),
+  isValid: s.f("isValid", S$RescriptSchema.int),
+  isPlain: s.f("isPlain", S$RescriptSchema.int),
+  columns: s.f("columns", S$RescriptSchema.array(S$RescriptSchema.string)),
+  directions: s.f("directions", S$RescriptSchema.array(S$RescriptSchema.string))
+})));
+
+function makeCatalogQuery(pgSchema) {
+  return `SELECT
+  t.relname AS "tableName",
+  i.relname AS "indexName",
+  am.amname AS "method",
+  CASE WHEN ix.indisvalid AND ix.indisready THEN 1 ELSE 0 END AS "isValid",
+  CASE
+    WHEN ix.indisunique OR ix.indpred IS NOT NULL OR ix.indexprs IS NOT NULL THEN 0
+    ELSE 1
+  END AS "isPlain",
+  array_agg(
+    CASE WHEN k.attnum = 0
+      THEN pg_get_indexdef(ix.indexrelid, k.ord::int, true)
+      ELSE a.attname
+    END ORDER BY k.ord
+  ) AS "columns",
+  array_agg(
+    CASE WHEN (ix.indoption[k.ord - 1] & 1) = 1 THEN 'DESC' ELSE 'ASC' END ORDER BY k.ord
+  ) AS "directions"
+FROM pg_index ix
+JOIN pg_class i ON i.oid = ix.indexrelid
+JOIN pg_class t ON t.oid = ix.indrelid
+JOIN pg_namespace n ON n.oid = t.relnamespace
+JOIN pg_am am ON am.oid = i.relam
+JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON k.ord <= ix.indnkeyatts
+LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+WHERE n.nspname = '` + pgSchema + `'
+GROUP BY t.relname, i.relname, am.amname, ix.indisvalid, ix.indisready,
+         ix.indisunique, ix.indpred, ix.indexprs;`;
+}
+
+function make() {
+  return {
+    keys: new Set(),
+    invalidByName: {},
+    inflight: {},
+    tableQueue: {}
+  };
+}
+
+function has(registry, key) {
+  return registry.keys.has(key);
+}
+
+function add(registry, key) {
+  registry.keys.add(key);
+}
+
+function size(registry) {
+  return registry.keys.size;
+}
+
+function toArray(registry) {
+  return Array.from(registry.keys).toSorted(Primitive_string.compare);
+}
+
+function getInvalid(registry, name) {
+  return registry.invalidByName[name];
+}
+
+function clearInvalidName(registry, name) {
+  Utils.Dict.deleteInPlace(registry.invalidByName, name);
+}
+
+function reload(registry, rows) {
+  registry.keys.clear();
+  Object.keys(registry.invalidByName).forEach(name => Utils.Dict.deleteInPlace(registry.invalidByName, name));
+  let invalidIndexNames = [];
+  rows.forEach(row => {
+    let key = makeKey(row.tableName, row.columns.map((name, idx) => {
+      let match = row.directions[idx];
+      let tmp;
+      tmp = match === "DESC" ? "Desc" : "Asc";
+      return {
+        name: name,
+        direction: tmp
+      };
+    }), row.method);
+    if (row.isValid === 0) {
+      invalidIndexNames.push(row.indexName);
+      registry.invalidByName[row.indexName] = {
+        key: key,
+        isRepairable: row.isPlain === 1
+      };
+      return;
+    } else {
+      return add(registry, key);
+    }
+  });
+  return invalidIndexNames;
+}
+
+function ensure(registry, key, tableName, build) {
+  if (registry.keys.has(key)) {
+    return Promise.resolve();
+  }
+  let promise = registry.inflight[key];
+  if (promise !== undefined) {
+    return promise;
+  }
+  let tail = registry.tableQueue[tableName];
+  let tail$1 = tail !== undefined ? tail : Promise.resolve();
+  let promise$1 = tail$1.then(() => {
+    if (registry.keys.has(key)) {
+      return Promise.resolve();
+    } else {
+      return build();
+    }
+  }).then(() => add(registry, key));
+  registry.inflight[key] = promise$1;
+  registry.tableQueue[tableName] = Utils.$$Promise.silentCatch(promise$1);
+  return promise$1.finally(() => Utils.Dict.deleteInPlace(registry.inflight, key));
+}
+
+function truncateIndexName(description) {
+  if (description.length > 63) {
+    return description.slice(0, 63);
+  } else {
+    return description;
+  }
+}
+
+function validateIndexNamesOrThrow(descriptions) {
+  let byName = {};
+  descriptions.forEach(description => {
+    let name = truncateIndexName(description);
+    let existing = byName[name];
+    if (existing !== undefined && existing !== description) {
+      return Stdlib_JsError.throwWithMessage(`Index names "` + existing + `" and "` + description + `" both truncate to "` + name + `" at PostgreSQL's ` + (63).toString() + `-character identifier limit. Rename a field or an entity so the generated index names stay distinct.`);
+    } else {
+      byName[name] = description;
+      return;
+    }
+  });
+}
+
+let btree = "btree";
+
+let pgMaxIdentifierLength = 63;
+
+export {
+  btree,
+  fromIndexFields,
+  makeKey,
+  catalogRowsSchema,
+  makeCatalogQuery,
+  make,
+  has,
+  add,
+  size,
+  toArray,
+  getInvalid,
+  clearInvalidName,
+  reload,
+  ensure,
+  pgMaxIdentifierLength,
+  truncateIndexName,
+  validateIndexNamesOrThrow,
+}
+/* catalogRowsSchema Not a pure module */

package/src/db/InternalTable.res

@@ -164,6 +164,13 @@ SET ${setClauses->Array.joinUnsafe(",\n    ")}
 WHERE "${(#id: field :> string)}" = $1;`
   }
 
+  // Written in the same transaction as the deferred schema indexes, so a chain
+  // is never reported ready without the indexes the schema promises.
+  let makeSetReadyAtQuery = (~pgSchema) =>
+    `UPDATE "${pgSchema}"."${table.tableName}"
+SET "${(#ready_at: field :> string)}" = $1
+WHERE "${(#id: field :> string)}" = ANY($2::int[]);`
+
   type rawInitialState = {
     id: int,
     startBlock: int,

package/src/db/InternalTable.res.mjs

@@ -101,6 +101,12 @@ SET ` + setClauses.join(",\n    ") + `
 WHERE "` + "id" + `" = $1;`;
 }
 
+function makeSetReadyAtQuery(pgSchema) {
+  return `UPDATE "` + pgSchema + `"."` + table.tableName + `"
+SET "` + "ready_at" + `" = $1
+WHERE "` + "id" + `" = ANY($2::int[]);`;
+}
+
 function makeGetInitialStateQuery(pgSchema) {
   return `SELECT "` + "id" + `" as "id",
 "` + "start_block" + `" as "startBlock",
@@ -213,6 +219,7 @@ let Chains = {
   makeInitialValuesQuery: makeInitialValuesQuery,
   metaFields: metaFields,
   makeMetaFieldsUpdateQuery: makeMetaFieldsUpdateQuery,
+  makeSetReadyAtQuery: makeSetReadyAtQuery,
   makeGetInitialStateQuery: makeGetInitialStateQuery,
   makeGetIndexingAddressesQuery: makeGetIndexingAddressesQuery,
   getInitialState: getInitialState,

package/src/db/Table.res

@@ -190,14 +190,14 @@ type compositeIndexField = {
 type table = {
   tableName: string,
   fields: array<fieldOrDerived>,
-  compositeIndices: array<array<compositeIndexField>>,
+  compositeIndexes: array<array<compositeIndexField>>,
   description: option<string>,
 }
 
-let mkTable = (tableName, ~compositeIndices=[], ~fields, ~description=?) => {
+let mkTable = (tableName, ~compositeIndexes=[], ~fields, ~description=?) => {
   tableName,
   fields,
-  compositeIndices,
+  compositeIndexes,
   description,
 }
 
@@ -355,11 +355,11 @@ let pgRowsSchema: table => S.t<array<unknown>> = Utils.WeakMap.memoize(table =>
 exception NonExistingTableField(string)
 
 /*
-Gets all composite indicies (whether they are single indices or not)
+Gets all composite indexes (whether they are single indexes or not)
 And maps the fields defined to their actual db name (some have _id suffix)
 */
-let getUnfilteredCompositeIndicesUnsafe = (table): array<array<compositeIndexField>> => {
-  table.compositeIndices->Array.map(compositeIndex =>
+let getUnfilteredCompositeIndexesUnsafe = (table): array<array<compositeIndexField>> => {
+  table.compositeIndexes->Array.map(compositeIndex =>
     compositeIndex->Array.map(indexField => {
       let dbFieldName = switch table->getFieldByName(indexField.fieldName) {
       | Some(field) => field->getPgFieldName
@@ -469,10 +469,10 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
 }
 
 /*
-Gets all single indicies
+Gets all single indexes
 And maps the fields defined to their actual db name (some have _id suffix)
 */
-let getSingleIndices = (table): array<string> => {
+let getSingleIndexes = (table): array<string> => {
   let indexFields = table.fields->Array.filterMap(field =>
     switch field {
     | Field(field) if field.isIndex => Some(field->getPgDbFieldName)
@@ -481,8 +481,8 @@ let getSingleIndices = (table): array<string> => {
   )
 
   table
-  ->getUnfilteredCompositeIndicesUnsafe
-  //get all composite indices with only 1 field defined
+  ->getUnfilteredCompositeIndexesUnsafe
+  //get all composite indexes with only 1 field defined
   //this is still a single index
   ->Array.filterMap(cidx =>
     switch cidx {
@@ -498,11 +498,11 @@ let getSingleIndices = (table): array<string> => {
 }
 
 /*
-Gets all composite indicies
+Gets all composite indexes
 And maps the fields defined to their actual db name (some have _id suffix)
 */
-let getCompositeIndices = (table): array<array<compositeIndexField>> => {
+let getCompositeIndexes = (table): array<array<compositeIndexField>> => {
   table
-  ->getUnfilteredCompositeIndicesUnsafe
+  ->getUnfilteredCompositeIndexesUnsafe
   ->Array.filter(ind => ind->Array.length > 1)
 }

package/src/db/Table.res.mjs

@@ -153,12 +153,12 @@ function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNu
   );
 }
 
-function mkTable(tableName, compositeIndicesOpt, fields, description) {
-  let compositeIndices = compositeIndicesOpt !== undefined ? compositeIndicesOpt : [];
+function mkTable(tableName, compositeIndexesOpt, fields, description) {
+  let compositeIndexes = compositeIndexesOpt !== undefined ? compositeIndexesOpt : [];
   return {
     tableName: tableName,
     fields: fields,
-    compositeIndices: compositeIndices,
+    compositeIndexes: compositeIndexes,
     description: description
   };
 }
@@ -304,8 +304,8 @@ let pgRowsSchema = Utils.$$WeakMap.memoize(table => makeRowsSchema(table, getPgD
 
 let NonExistingTableField = /* @__PURE__ */Primitive_exceptions.create("Table.NonExistingTableField");
 
-function getUnfilteredCompositeIndicesUnsafe(table) {
-  return table.compositeIndices.map(compositeIndex => compositeIndex.map(indexField => {
+function getUnfilteredCompositeIndexesUnsafe(table) {
+  return table.compositeIndexes.map(compositeIndex => compositeIndex.map(indexField => {
     let field = getFieldByName(table, indexField.fieldName);
     let dbFieldName;
     if (field !== undefined) {
@@ -419,7 +419,7 @@ function toSqlParams(table, schema, pgSchema) {
   };
 }
 
-function getSingleIndices(table) {
+function getSingleIndexes(table) {
   let indexFields = Stdlib_Array.filterMap(table.fields, field => {
     if (field.TAG !== "Field") {
       return;
@@ -429,7 +429,7 @@ function getSingleIndices(table) {
       return getPgDbFieldName(field$1);
     }
   });
-  return Array.from(new Set(Stdlib_Array.filterMap(getUnfilteredCompositeIndicesUnsafe(table), cidx => {
+  return Array.from(new Set(Stdlib_Array.filterMap(getUnfilteredCompositeIndexesUnsafe(table), cidx => {
     if (cidx.length !== 1) {
       return;
     }
@@ -438,8 +438,8 @@ function getSingleIndices(table) {
   }).concat([indexFields]).flat())).toSorted(Primitive_string.compare);
 }
 
-function getCompositeIndices(table) {
-  return getUnfilteredCompositeIndicesUnsafe(table).filter(ind => ind.length > 1);
+function getCompositeIndexes(table) {
+  return getUnfilteredCompositeIndexesUnsafe(table).filter(ind => ind.length > 1);
 }
 
 export {
@@ -473,9 +473,9 @@ export {
   rowsSchema,
   pgRowsSchema,
   NonExistingTableField,
-  getUnfilteredCompositeIndicesUnsafe,
+  getUnfilteredCompositeIndexesUnsafe,
   toSqlParams,
-  getSingleIndices,
-  getCompositeIndices,
+  getSingleIndexes,
+  getCompositeIndexes,
 }
 /* idsArraySchema Not a pure module */