envio 3.15.0-subgraph → 3.16.0

package/src/bindings/ClickHouse.res

@@ -1,325 +1,3 @@
-let fieldTypeName = (fieldType: Table.fieldType) =>
-  switch fieldType {
-  | String => "String"
-  | Boolean => "Boolean"
-  | Uint32 => "Uint32"
-  | UInt52 => "UInt52"
-  | SmallInt =>
-    JsError.throwWithMessage("ClickHouse doesn't support the internal SmallInt column type")
-  | Bytea => "Bytea"
-  | UInt64 => "UInt64"
-  | Int32 => "Int32"
-  | ChainId => "ChainId"
-  | Number => "Number"
-  | Serial => "Serial"
-  | BigSerial => "BigSerial"
-  | Json => "Json"
-  | Date => "Date"
-  | BigInt(_) => "BigInt"
-  | BigDecimal(_) => "BigDecimal"
-  | Enum(_) => "Enum"
-  }
-
-let column = (
-  ~name,
-  ~rowName=?,
-  ~fieldName=?,
-  ~fieldType: Table.fieldType,
-  ~isNullable=false,
-  ~isArray=false,
-): StorageClient.clickHouseColumn => {
-  name,
-  ?rowName,
-  ?fieldName,
-  fieldType: fieldType->fieldTypeName,
-  isNullable,
-  isArray,
-  precision: ?switch fieldType {
-  | BigInt({?precision}) => precision
-  | BigDecimal({?config}) => config->Option.map(((precision, _)) => precision)
-  | _ => None
-  },
-  scale: ?switch fieldType {
-  | BigDecimal({?config}) => config->Option.map(((_, scale)) => scale)
-  | _ => None
-  },
-  enumVariants: ?switch fieldType {
-  | Enum({config}) =>
-    Some(config.variants->Array.map(variant => variant->(Utils.magic: Table.enum => string)))
-  | _ => None
-  },
-}
-
-let fieldColumn = (field: Table.field) =>
-  column(
-    ~name=field->Table.getClickHouseDbFieldName,
-    ~rowName=field->Table.getPgDbFieldName,
-    ~fieldName=field.fieldName,
-    ~fieldType=field.fieldType,
-    ~isNullable=field.isNullable,
-    ~isArray=field.isArray,
-  )
-
-let entityTable = (entityConfig: Internal.entityConfig): StorageClient.clickHouseTable => {
-  let options = entityConfig.storage.clickhouseOptions
-  {
-    name: entityConfig.name,
-    historyTable: EntityHistory.historyTableName(
-      ~entityName=entityConfig.name,
-      ~entityIndex=entityConfig.index,
-    ),
-    columns: entityConfig.table.fields->Array.filterMap(field =>
-      switch field {
-      | Table.Field(f) => Some(fieldColumn(f))
-      | DerivedFrom(_) => None
-      }
-    ),
-    chainIdColumn: ?(
-      entityConfig.table->Table.getChainIdField->Option.map(Table.getClickHouseDbFieldName)
-    ),
-    partitionBy: ?(options->Option.flatMap(options => options.partitionBy)),
-    orderBy: ?(options->Option.flatMap(options => options.orderBy)),
-    ttl: ?(options->Option.flatMap(options => options.ttl)),
-    skippingIndexes: ?(
-      options->Option.flatMap(options =>
-        options.skippingIndexes->Option.map(indexes =>
-          indexes->Array.map(
-            (index): StorageClient.skippingIndex => {
-              name: index.name,
-              expr: index.expr,
-              indexType: index.type_,
-              granularity: ?index.granularity,
-            },
-          )
-        )
-      )
-    ),
-  }
-}
-
-// Visits every node on the way into JSON text. A bigint would make
-// `JSON.stringify` throw and fail the whole batch, so it travels as its digits.
-%%private(
-  let jsonSafe = (~column) =>
-    (_, value: JSON.t) =>
-      switch value->typeof {
-      | #bigint =>
-        value->(Utils.magic: JSON.t => unknown)->Staging.stringOf->(Utils.magic: string => JSON.t)
-      // A Uint8Array inside a list column travels as its byte values, which the
-      // addon reads back into raw bytes.
-      | #object =>
-        switch value->(Utils.magic: JSON.t => unknown)->Utils.Bytes.asUint8Array {
-        | Some(bytes) =>
-          bytes
-          ->(Utils.magic: Uint8Array.t => Array.arrayLike<int>)
-          ->Array.fromArrayLike
-          ->(Utils.magic: array<int> => JSON.t)
-        | None => value
-        }
-      | #number =>
-        let _ = value->(Utils.magic: JSON.t => float)->Staging.finiteOrThrow(~column)
-        value
-      | _ => value
-      }
-)
-
-type cell = Change.t<Internal.entity> => unknown
-
-type historyCells = {
-  setCells: array<cell>,
-  deleteCells: array<cell>,
-}
-
-type table = {
-  handle: int,
-  name: string,
-  columns: array<Staging.column>,
-  // An entity's history cells, by the scope whose chain id they stamp.
-  historyCells: dict<historyCells>,
-}
-
-let makeTable = (~handle, ~name, {names, kinds, nullable}: StorageClient.clickHouseRegistered) => {
-  handle,
-  name,
-  columns: names->Array.mapWithIndex((name, index): Staging.column => {
-    name,
-    kind: kinds->Array.getUnsafe(index)->Staging.kindOfOrdinal,
-    isNullable: nullable->Array.getUnsafe(index),
-    replacer: Replacer(jsonSafe(~column=name)),
-  }),
-  historyCells: Dict.make(),
-}
-
-// A Json column holds the document's text. Staging writes a string as is, so a
-// document that is a string has to become its own JSON text here, or it would
-// read back as something JSON can't parse. JSON `null` and an absent value are
-// both stored as `null`: the column is never Nullable.
-%%private(
-  let documentText = (value: unknown) =>
-    switch value->(Utils.magic: unknown => Nullable.t<JSON.t>) {
-    | Value(_) => value->Sql.canonicalDocument->(Utils.magic: string => unknown)
-    | Null | Undefined => "null"->(Utils.magic: string => unknown)
-    }
-)
-
-%%private(
-  let compileSerializer = schema =>
-    S.compile(schema, ~input=Value, ~output=Json, ~typeValidation=false, ~mode=Sync)->(
-      Utils.magic: (unknown => JSON.t) => unknown => unknown
-    )
-)
-
-%%private(
-  let documentsText = (f: Table.field): (unknown => unknown) =>
-    if f.isArray {
-      value =>
-        switch value->(Utils.magic: unknown => Nullable.t<array<unknown>>) {
-        | Value(documents) =>
-          documents->Array.map(documentText)->(Utils.magic: array<unknown> => unknown)
-        | Null | Undefined => value
-        }
-    } else {
-      documentText
-    }
-)
-
-%%private(
-  let serializerOf = (f: Table.field): (unknown => unknown) => {
-    let shaped = baseSchema =>
-      if f.isNullable {
-        Utils.Schema.nullTolerant(baseSchema)->S.toUnknown
-      } else if f.isArray {
-        S.array(baseSchema)->S.toUnknown
-      } else {
-        baseSchema
-      }
-    switch f.fieldType {
-    | Json => documentsText(f)
-    | Date => compileSerializer(shaped(Utils.Schema.clickHouseDate->S.toUnknown))
-    | Bytea => compileSerializer(shaped(S.json(~validate=false)->S.toUnknown))
-    | ChainId => compileSerializer(ChainId.schema->S.toUnknown)
-    | _ => compileSerializer(f.fieldSchema)
-    }
-  }
-)
-
-@get external changeEntity: Change.t<Internal.entity> => dict<unknown> = "entity"
-
-%%private(let absent: unknown = %raw(`undefined`))
-
-%%private(
-  let makeHistoryCells = (
-    table,
-    ~entityConfig: Internal.entityConfig,
-    ~scope: Internal.chainScope,
-  ): historyCells => {
-    let sourceTable = entityConfig.table
-    let chainIdTag = switch (
-      sourceTable->Table.getChainIdField,
-      scope->Internal.chainScopeChainId,
-    ) {
-    | (Some(field), Some(chainId)) =>
-      Some((field->Table.getClickHouseDbFieldName, chainId->(Utils.magic: ChainId.t => unknown)))
-    | _ => None
-    }
-    let fieldsByColumn = Dict.make()
-    sourceTable.fields->Array.forEach(field =>
-      switch field {
-      | Table.Field(f) => fieldsByColumn->Dict.set(f->Table.getClickHouseDbFieldName, f)
-      | DerivedFrom(_) => ()
-      }
-    )
-
-    let setCells = []
-    let deleteCells = []
-    let registeredNames = table.columns->Array.map(column => column.name)->Utils.Set.fromArray
-    table.columns->Array.forEach(({name}) => {
-      let (set, delete) = if name === EntityHistory.checkpointIdFieldName {
-        let cell = change => change->Change.getCheckpointId->(Utils.magic: bigint => unknown)
-        (cell, cell)
-      } else if name === EntityHistory.changeFieldName {
-        (
-          _ => (EntityHistory.RowAction.SET :> string)->(Utils.magic: string => unknown),
-          _ => (EntityHistory.RowAction.DELETE :> string)->(Utils.magic: string => unknown),
-        )
-      } else {
-        switch (chainIdTag, fieldsByColumn->Utils.Dict.dangerouslyGetNonOption(name)) {
-        | (Some((column, chainId)), _) if column === name => (_ => chainId, _ => chainId)
-        | (_, Some(f)) =>
-          let serialize = serializerOf(f)
-          let apiName = f->Table.getApiFieldName
-          if apiName === Table.idFieldName {
-            let cell = change =>
-              serialize(change->Change.getEntityId->(Utils.magic: EntityId.t => unknown))
-            (cell, cell)
-          } else {
-            (change => serialize(change->changeEntity->Dict.getUnsafe(apiName)), _ => absent)
-          }
-        | (_, None) =>
-          JsError.throwWithMessage(
-            `ClickHouse table "${table.name}" registered a column "${name}" that entity "${entityConfig.name}" has no value for`,
-          )
-        }
-      }
-      setCells->Array.push(set)
-      deleteCells->Array.push(delete)
-    })
-
-    fieldsByColumn->Dict.forEachWithKey((f, column) =>
-      if !(registeredNames->Utils.Set.has(column)) {
-        JsError.throwWithMessage(
-          `ClickHouse table "${table.name}" registered no column for field "${f.fieldName}" of entity "${entityConfig.name}"`,
-        )
-      }
-    )
-
-    {setCells, deleteCells}
-  }
-)
-
-// Every change as a row of the entity's history: a deletion keeps only the
-// columns that say which entity it removed.
-let stageChangesOrThrow = (
-  arena,
-  table,
-  ~entityConfig: Internal.entityConfig,
-  ~scope: Internal.chainScope,
-  ~changes: array<Change.t<Internal.entity>>,
-) => {
-  let stage =
-    arena->Staging.begin(~table=table.handle, ~rows=changes->Array.length, ~columns=table.columns)
-  try {
-    let cacheKey = scope->Internal.chainScopeToString
-    let cells = switch table.historyCells->Utils.Dict.dangerouslyGetNonOption(cacheKey) {
-    | Some(cached) => cached
-    | None =>
-      let cells = table->makeHistoryCells(~entityConfig, ~scope)
-      table.historyCells->Dict.set(cacheKey, cells)
-      cells
-    }
-    let columns = stage->Staging.columnCount
-    changes->Array.forEachWithIndex((change, row) => {
-      let (cells, write) = switch change {
-      | Change.Set(_) => (cells.setCells, Staging.writeValue)
-      | Delete(_) => (cells.deleteCells, Staging.writeDeletedValue)
-      }
-      for column in 0 to columns - 1 {
-        stage->write(~column, ~row, (cells->Array.getUnsafe(column))(change))
-      }
-    })
-    stage->Staging.commit
-  } catch {
-  | exn =>
-    stage->Staging.abort
-    throw(
-      Persistence.StorageError({
-        message: `Failed to convert items for ClickHouse table "${table.name}"`,
-        reason: exn->Utils.prettifyExn,
-      }),
-    )
-  }
-}
-
 // Every connection setting has to be there: an unset one would otherwise reach
 // the server as an empty value and fail there, for a reason naming neither.
 let optionsFromEnvOrThrow = (): StorageClient.clickHouseOptions => {

package/src/bindings/ClickHouse.res.mjs

@@ -1,340 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Env from "../Env.res.mjs";
-import * as Sql from "../db/Sql.res.mjs";
-import * as Table from "../db/Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as ChainId from "../ChainId.res.mjs";
-import * as Staging from "../Staging.res.mjs";
-import * as Internal from "../Internal.res.mjs";
-import * as Persistence from "../Persistence.res.mjs";
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as EntityHistory from "../db/EntityHistory.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-
-function fieldTypeName(fieldType) {
-  if (typeof fieldType !== "object") {
-    switch (fieldType) {
-      case "String" :
-        return "String";
-      case "Boolean" :
-        return "Boolean";
-      case "Uint32" :
-        return "Uint32";
-      case "UInt52" :
-        return "UInt52";
-      case "SmallInt" :
-        return Stdlib_JsError.throwWithMessage("ClickHouse doesn't support the internal SmallInt column type");
-      case "Bytea" :
-        return "Bytea";
-      case "UInt64" :
-        return "UInt64";
-      case "Int32" :
-        return "Int32";
-      case "ChainId" :
-        return "ChainId";
-      case "Number" :
-        return "Number";
-      case "Serial" :
-        return "Serial";
-      case "BigSerial" :
-        return "BigSerial";
-      case "Json" :
-        return "Json";
-      case "Date" :
-        return "Date";
-    }
-  } else {
-    switch (fieldType.type) {
-      case "BigInt" :
-        return "BigInt";
-      case "BigDecimal" :
-        return "BigDecimal";
-      case "Enum" :
-        return "Enum";
-    }
-  }
-}
-
-function column(name, rowName, fieldName, fieldType, isNullableOpt, isArrayOpt) {
-  let isNullable = isNullableOpt !== undefined ? isNullableOpt : false;
-  let isArray = isArrayOpt !== undefined ? isArrayOpt : false;
-  let tmp;
-  if (typeof fieldType !== "object") {
-    tmp = undefined;
-  } else {
-    switch (fieldType.type) {
-      case "BigInt" :
-        tmp = fieldType.precision;
-        break;
-      case "BigDecimal" :
-        tmp = Stdlib_Option.map(fieldType.config, param => param[0]);
-        break;
-      default:
-        tmp = undefined;
-    }
-  }
-  let tmp$1;
-  tmp$1 = typeof fieldType !== "object" || fieldType.type !== "BigDecimal" ? undefined : Stdlib_Option.map(fieldType.config, param => param[1]);
-  let tmp$2;
-  tmp$2 = typeof fieldType !== "object" || fieldType.type !== "Enum" ? undefined : fieldType.config.variants.map(variant => variant);
-  return {
-    name: name,
-    rowName: rowName,
-    fieldName: fieldName,
-    fieldType: fieldTypeName(fieldType),
-    isNullable: isNullable,
-    isArray: isArray,
-    precision: tmp,
-    scale: tmp$1,
-    enumVariants: tmp$2
-  };
-}
-
-function fieldColumn(field) {
-  return column(Table.getClickHouseDbFieldName(field), Table.getPgDbFieldName(field), field.fieldName, field.fieldType, field.isNullable, field.isArray);
-}
-
-function entityTable(entityConfig) {
-  let options = entityConfig.storage.clickhouseOptions;
-  return {
-    name: entityConfig.name,
-    historyTable: EntityHistory.historyTableName(entityConfig.name, entityConfig.index),
-    columns: Stdlib_Array.filterMap(entityConfig.table.fields, field => {
-      if (field.TAG === "Field") {
-        return fieldColumn(field._0);
-      }
-    }),
-    chainIdColumn: Stdlib_Option.map(Table.getChainIdField(entityConfig.table), Table.getClickHouseDbFieldName),
-    partitionBy: Stdlib_Option.flatMap(options, options => options.partitionBy),
-    orderBy: Stdlib_Option.flatMap(options, options => options.orderBy),
-    ttl: Stdlib_Option.flatMap(options, options => options.ttl),
-    skippingIndexes: Stdlib_Option.flatMap(options, options => Stdlib_Option.map(options.skippingIndexes, indexes => indexes.map(index => ({
-      name: index.name,
-      expr: index.expr,
-      indexType: index.type,
-      granularity: index.granularity
-    }))))
-  };
-}
-
-function jsonSafe(column) {
-  return (param, value) => {
-    let match = typeof value;
-    if (match === "bigint") {
-      return String(value);
-    }
-    if (match !== "object") {
-      if (match === "number") {
-        Staging.finiteOrThrow(value, column);
-        return value;
-      } else {
-        return value;
-      }
-    }
-    let bytes = Utils.Bytes.asUint8Array(value);
-    if (bytes !== undefined) {
-      return Array.from(bytes);
-    } else {
-      return value;
-    }
-  };
-}
-
-function makeTable(handle, name, param) {
-  let nullable = param.nullable;
-  let kinds = param.kinds;
-  return {
-    handle: handle,
-    name: name,
-    columns: param.names.map((name, index) => ({
-      name: name,
-      kind: Staging.kindOfOrdinal(kinds[index]),
-      isNullable: nullable[index],
-      replacer: jsonSafe(name)
-    })),
-    historyCells: {}
-  };
-}
-
-function documentText(value) {
-  if (value == null) {
-    return "null";
-  } else {
-    return Sql.canonicalDocument(value);
-  }
-}
-
-function compileSerializer(schema) {
-  return S$RescriptSchema.compile(schema, "Output", "Json", "Sync", false);
-}
-
-function serializerOf(f) {
-  let shaped = baseSchema => {
-    if (f.isNullable) {
-      return Utils.Schema.nullTolerant(baseSchema);
-    } else if (f.isArray) {
-      return S$RescriptSchema.array(baseSchema);
-    } else {
-      return baseSchema;
-    }
-  };
-  let match = f.fieldType;
-  if (typeof match === "object") {
-    return compileSerializer(f.fieldSchema);
-  }
-  switch (match) {
-    case "Bytea" :
-      return compileSerializer(shaped(S$RescriptSchema.json(false)));
-    case "ChainId" :
-      return compileSerializer(ChainId.schema);
-    case "Json" :
-      if (f.isArray) {
-        return value => {
-          if (value == null) {
-            return value;
-          } else {
-            return value.map(documentText);
-          }
-        };
-      } else {
-        return documentText;
-      }
-    case "Date" :
-      return compileSerializer(shaped(Utils.Schema.clickHouseDate));
-    default:
-      return compileSerializer(f.fieldSchema);
-  }
-}
-
-let absent = undefined;
-
-function makeHistoryCells(table, entityConfig, scope) {
-  let sourceTable = entityConfig.table;
-  let match = Table.getChainIdField(sourceTable);
-  let match$1 = Internal.chainScopeChainId(scope);
-  let chainIdTag = match !== undefined && match$1 !== undefined ? [
-      Table.getClickHouseDbFieldName(match),
-      Primitive_option.valFromOption(match$1)
-    ] : undefined;
-  let fieldsByColumn = {};
-  sourceTable.fields.forEach(field => {
-    if (field.TAG !== "Field") {
-      return;
-    }
-    let f = field._0;
-    fieldsByColumn[Table.getClickHouseDbFieldName(f)] = f;
-  });
-  let setCells = [];
-  let deleteCells = [];
-  let registeredNames = new Set(table.columns.map(column => column.name));
-  table.columns.forEach(param => {
-    let name = param.name;
-    let match;
-    if (name === EntityHistory.checkpointIdFieldName) {
-      let cell = change => change.checkpointId;
-      match = [
-        cell,
-        cell
-      ];
-    } else if (name === EntityHistory.changeFieldName) {
-      match = [
-        param => "SET",
-        param => "DELETE"
-      ];
-    } else {
-      let match$1 = fieldsByColumn[name];
-      let exit = 0;
-      if (chainIdTag !== undefined && chainIdTag[0] === name) {
-        let chainId = chainIdTag[1];
-        match = [
-          param => chainId,
-          param => chainId
-        ];
-      } else {
-        exit = 1;
-      }
-      if (exit === 1) {
-        if (match$1 !== undefined) {
-          let serialize = serializerOf(match$1);
-          let apiName = Table.getApiFieldName(match$1);
-          if (apiName === Table.idFieldName) {
-            let cell$1 = change => serialize(change.entityId);
-            match = [
-              cell$1,
-              cell$1
-            ];
-          } else {
-            match = [
-              change => serialize(change.entity[apiName]),
-              param => absent
-            ];
-          }
-        } else {
-          match = Stdlib_JsError.throwWithMessage(`ClickHouse table "` + table.name + `" registered a column "` + name + `" that entity "` + entityConfig.name + `" has no value for`);
-        }
-      }
-    }
-    setCells.push(match[0]);
-    deleteCells.push(match[1]);
-  });
-  Stdlib_Dict.forEachWithKey(fieldsByColumn, (f, column) => {
-    if (!registeredNames.has(column)) {
-      return Stdlib_JsError.throwWithMessage(`ClickHouse table "` + table.name + `" registered no column for field "` + f.fieldName + `" of entity "` + entityConfig.name + `"`);
-    }
-  });
-  return {
-    setCells: setCells,
-    deleteCells: deleteCells
-  };
-}
-
-function stageChangesOrThrow(arena, table, entityConfig, scope, changes) {
-  let stage = Staging.begin(arena, table.handle, changes.length, table.columns);
-  try {
-    let cacheKey = Internal.chainScopeToString(scope);
-    let cached = table.historyCells[cacheKey];
-    let cells;
-    if (cached !== undefined) {
-      cells = cached;
-    } else {
-      let cells$1 = makeHistoryCells(table, entityConfig, scope);
-      table.historyCells[cacheKey] = cells$1;
-      cells = cells$1;
-    }
-    let columns = Staging.columnCount(stage);
-    changes.forEach((change, row) => {
-      let match;
-      match = change.type === "SET" ? [
-          cells.setCells,
-          Staging.writeValue
-        ] : [
-          cells.deleteCells,
-          Staging.writeDeletedValue
-        ];
-      let write = match[1];
-      let cells$2 = match[0];
-      for (let column = 0; column < columns; ++column) {
-        write(stage, column, row, cells$2[column](change));
-      }
-    });
-    return Staging.commit(stage);
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
-    Staging.abort(stage);
-    throw {
-      RE_EXN_ID: Persistence.StorageError,
-      message: `Failed to convert items for ClickHouse table "` + table.name + `"`,
-      reason: Utils.prettifyExn(exn),
-      Error: new Error()
-    };
-  }
-}
 
 function optionsFromEnvOrThrow() {
   let missing = [];
@@ -364,12 +32,6 @@ function optionsFromEnvOrThrow() {
 }
 
 export {
-  fieldTypeName,
-  column,
-  fieldColumn,
-  entityTable,
-  makeTable,
-  stageChangesOrThrow,
   optionsFromEnvOrThrow,
 }
 /* Env Not a pure module */