@certik/skynet 0.24.0 → 0.25.0

package/dist/indexer.js

@@ -1,1099 +0,0 @@
-// src/selector.ts
-function getSelectorDesc(selector) {
-  return Object.keys(selector).map((name) => {
-    return `          --${name.padEnd(14)}${selector[name].desc || selector[name].description || ""}`;
-  }).join(`
-`);
-}
-function getSelectorFlags(selector) {
-  return Object.keys(selector).reduce((acc, name) => {
-    const flag = {
-      type: selector[name].type || "string",
-      ...selector[name]
-    };
-    if (!selector[name].optional && selector[name].isRequired !== false) {
-      flag.isRequired = true;
-    }
-    return { ...acc, [name]: flag };
-  }, {});
-}
-function toSelectorString(selectorFlags, delim = ",") {
-  return Object.keys(selectorFlags).sort().map((flag) => {
-    return `${flag}=${selectorFlags[flag]}`;
-  }).join(delim);
-}
-function normalizeSelectorValue(v) {
-  return v.replace(/[^A-Za-z0-9]+/g, "-");
-}
-function getJobName(name, selectorFlags, mode) {
-  const selectorNamePart = Object.keys(selectorFlags).sort().map((name2) => selectorFlags[name2]).join("-");
-  let jobName = name;
-  if (mode) {
-    jobName += `-${mode}`;
-  }
-  if (selectorNamePart.length > 0) {
-    jobName += `-${normalizeSelectorValue(selectorNamePart)}`;
-  }
-  return jobName;
-}
-// src/env.ts
-function ensureAndGet(envName, defaultValue) {
-  return process.env[envName] || defaultValue;
-}
-function getEnvironment() {
-  return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
-}
-function getEnvOrThrow(envName) {
-  if (!process.env[envName]) {
-    throw new Error(`Must set environment variable ${envName}`);
-  }
-  return process.env[envName];
-}
-function isProduction() {
-  return getEnvironment() === "prd";
-}
-function isDev() {
-  return getEnvironment() === "dev";
-}
-// src/log.ts
-function isObject(a) {
-  return !!a && a.constructor === Object;
-}
-function print(o) {
-  if (Array.isArray(o)) {
-    return `[${o.map(print).join(", ")}]`;
-  }
-  if (isObject(o)) {
-    return `{${Object.keys(o).map((k) => `${k}: ${o[k]}`).join(", ")}}`;
-  }
-  return `${o}`;
-}
-function getLine(params) {
-  let line = "";
-  for (let i = 0, l = params.length;i < l; i++) {
-    line += `${print(params[i])} `.replace(/\n/gm, "\t");
-  }
-  return line.trim();
-}
-function timestamp() {
-  return new Date().toISOString();
-}
-var inline = {
-  debug: function(...args) {
-    if (true) {
-      console.log(`${timestamp()} ${getLine(args)}`);
-    }
-  },
-  log: function(...args) {
-    if (true) {
-      console.log(`${timestamp()} ${getLine(args)}`);
-    }
-  },
-  error: function(...args) {
-    if (true) {
-      console.error(`${timestamp()} ${getLine(args)}`);
-    }
-  }
-};
-var logger = {
-  debug: function(...args) {
-    if (true) {
-      console.log(`[${timestamp()}]`, ...args);
-    }
-  },
-  log: function(...args) {
-    if (true) {
-      console.log(`[${timestamp()}]`, ...args);
-    }
-  },
-  error: function(...args) {
-    if (true) {
-      console.error(`[${timestamp()}]`, ...args);
-    }
-  }
-};
-// src/object-hash.ts
-import xh from "@node-rs/xxhash";
-function getHash(obj) {
-  const xxh3 = xh.xxh3.Xxh3.withSeed();
-  hash(obj, xxh3);
-  return xxh3.digest().toString(16);
-}
-function hash(obj, xxh3) {
-  if (obj === null) {
-    xxh3.update("null");
-  } else if (obj === undefined) {
-    xxh3.update("undefined");
-  } else if (typeof obj === "string") {
-    xxh3.update(obj);
-  } else if (typeof obj === "number") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "boolean") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "bigint") {
-    xxh3.update(obj.toString());
-  } else if (obj instanceof Date) {
-    xxh3.update(obj.toISOString());
-  } else if (Array.isArray(obj)) {
-    arrayHash(obj, xxh3);
-  } else if (obj instanceof Set) {
-    setHash(obj, xxh3);
-  } else if (obj instanceof Map) {
-    mapHash(obj, xxh3);
-  } else if (typeof obj === "object") {
-    objectHash(obj, xxh3);
-  } else {
-    throw new Error(`Unsupported type: ${obj}`);
-  }
-}
-function arrayHash(array, xxh3) {
-  xxh3.update("[");
-  for (const obj of array) {
-    hash(obj, xxh3);
-  }
-  xxh3.update("]");
-}
-function setHash(_set, _xxh3) {
-  throw new Error("Set hashing not implemented");
-}
-function mapHash(map, xxh3) {
-  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
-}
-function objectHash(obj, xxh3) {
-  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
-}
-
-// src/availability.ts
-import pThrottle from "p-throttle";
-import pMemoize from "p-memoize";
-import QuickLRU from "quick-lru";
-async function wait(time) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, time);
-  });
-}
-async function exponentialRetry(func, {
-  maxRetry,
-  initialDuration,
-  growFactor,
-  test,
-  verbose
-}) {
-  let retries = maxRetry;
-  let duration = initialDuration || 5000;
-  const growFactorFinal = growFactor || 2;
-  let result = await func();
-  while (!test(result) && retries > 0) {
-    if (verbose) {
-      console.log("failed attempt result", result);
-      console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
-    }
-    retries = retries - 1;
-    await wait(duration);
-    result = await func();
-    duration = duration * growFactorFinal;
-  }
-  if (verbose) {
-    console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
-  }
-  return result;
-}
-function withRetry(func, options) {
-  let retries = options?.maxRetry || 3;
-  let duration = options?.initialDuration || 500;
-  const growFactorFinal = options?.growFactor || 2;
-  return async (...args) => {
-    do {
-      try {
-        return await func(...args);
-      } catch (error) {
-        retries = retries - 1;
-        if (retries <= 0) {
-          throw error;
-        }
-        await wait(duration);
-        duration = duration * growFactorFinal;
-      }
-    } while (retries > 0);
-    throw new Error("unreachable");
-  };
-}
-function memoize(func, options) {
-  if (!options) {
-    options = {};
-  }
-  if (!options.cache) {
-    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 1e4 });
-  }
-  if (!options.cacheKey) {
-    options.cacheKey = (args) => getHash(args);
-  }
-  return pMemoize(func, options);
-}
-// src/util.ts
-function range(startAt, endAt, step) {
-  const arr = [];
-  for (let i = startAt;i <= endAt; i += step) {
-    arr.push([i, Math.min(endAt, i + step - 1)]);
-  }
-  return arr;
-}
-function arrayGroup(array, groupSize) {
-  const groups = [];
-  for (let i = 0;i < array.length; i += groupSize) {
-    groups.push(array.slice(i, i + groupSize));
-  }
-  return groups;
-}
-function fillRange(start, end) {
-  const result = [];
-  for (let i = start;i <= end; i++) {
-    result.push(i);
-  }
-  return result;
-}
-// src/dynamodb.ts
-import {
-  DynamoDBDocumentClient,
-  ScanCommand,
-  BatchWriteCommand,
-  GetCommand,
-  PutCommand,
-  QueryCommand,
-  UpdateCommand
-} from "@aws-sdk/lib-dynamodb";
-import { DynamoDBClient, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
-var _dynamoDB;
-var _docClient;
-function getDynamoDB(forceNew = false) {
-  if (!_dynamoDB || forceNew) {
-    _dynamoDB = new DynamoDBClient;
-  }
-  return _dynamoDB;
-}
-function getDocClient(forceNew = false) {
-  const marshallOptions = {
-    convertEmptyValues: true,
-    removeUndefinedValues: true,
-    convertClassInstanceToMap: true
-  };
-  const unmarshallOptions = {
-    wrapNumbers: false
-  };
-  if (!_docClient || forceNew) {
-    _docClient = DynamoDBDocumentClient.from(getDynamoDB(), {
-      marshallOptions,
-      unmarshallOptions
-    });
-  }
-  return _docClient;
-}
-async function scanWholeTable(options) {
-  const dynamodb = getDocClient();
-  let items = [];
-  let count = 0;
-  let scannedCount = 0;
-  let data = await dynamodb.send(new ScanCommand(options));
-  while (data.LastEvaluatedKey) {
-    if (data.Items) {
-      items = items.concat(data.Items);
-    }
-    count += data.Count || 0;
-    scannedCount += data.ScannedCount || 0;
-    data = await dynamodb.send(new ScanCommand({ ...options, ExclusiveStartKey: data.LastEvaluatedKey }));
-  }
-  if (data.Items) {
-    items = items.concat(data.Items);
-  }
-  count += data.Count || 0;
-  scannedCount += data.ScannedCount || 0;
-  return {
-    Items: items,
-    Count: count,
-    ScannedCount: scannedCount
-  };
-}
-async function batchCreateRecords(tableName, records, maxWritingCapacity, verbose = false) {
-  if (verbose) {
-    console.log(`creating ${records.length} items in ${tableName}`);
-  }
-  const docClient = getDocClient();
-  let remainingItems = records;
-  let prevRemainingCount = remainingItems.length + 1;
-  let factor = 1;
-  let rejection = undefined;
-  while (remainingItems.length > 0 && factor <= 128 && !rejection) {
-    if (prevRemainingCount === remainingItems.length) {
-      await wait(5000 * factor);
-      factor = factor * 2;
-    }
-    if (factor >= 32) {
-      console.log(`WARNING: no progress for a long time for batchCreateRecords, please check`);
-    }
-    const slices = arrayGroup(remainingItems.slice(0, maxWritingCapacity), 25);
-    const results = await Promise.allSettled(slices.map((rs) => docClient.send(new BatchWriteCommand({
-      RequestItems: {
-        [tableName]: rs.map((record) => ({ PutRequest: { Item: record } }))
-      }
-    }))));
-    const isFulfilled = (p) => p.status === "fulfilled";
-    const isRejected = (p) => p.status === "rejected";
-    prevRemainingCount = remainingItems.length;
-    remainingItems = remainingItems.slice(maxWritingCapacity);
-    results.forEach((rs, idx) => {
-      if (isRejected(rs)) {
-        remainingItems = remainingItems.concat(slices[idx]);
-        rejection = rs;
-      } else if (isFulfilled(rs) && rs.value.UnprocessedItems && Object.keys(rs.value.UnprocessedItems).length > 0) {
-        const unprocessedItems = rs.value.UnprocessedItems[tableName].map((it) => it.PutRequest?.Item ?? []).flat();
-        remainingItems = remainingItems.concat(unprocessedItems);
-      }
-    });
-    if (verbose) {
-      console.log(`processed=${prevRemainingCount - remainingItems.length}, remaining=${remainingItems.length}`);
-    }
-  }
-  if (rejection) {
-    console.log("batchCreateRecords rejected", rejection);
-    throw new Error(`batchCreateRecords rejected, failed items=${remainingItems.length}`);
-  }
-  if (remainingItems.length > 0) {
-    console.log(`failed batchCreateRecords, failed items=${remainingItems.length}`);
-    throw new Error(`batchCreateRecords retry failed, failed items=${remainingItems.length}`);
-  }
-}
-async function createRecord(tableName, fields, verbose = false) {
-  if (verbose) {
-    console.log("creating", tableName, fields);
-  }
-  const docClient = getDocClient();
-  const params = {
-    TableName: tableName,
-    Item: fields
-  };
-  return docClient.send(new PutCommand(params));
-}
-async function readRecord(tableName, key, verbose = false) {
-  if (verbose) {
-    console.log("reading", tableName, key);
-  }
-  const docClient = getDocClient();
-  const record = await docClient.send(new GetCommand({
-    TableName: tableName,
-    Key: key
-  }));
-  return record.Item;
-}
-async function getRecordsByKey(tableName, keys, indexName) {
-  const docClient = getDocClient();
-  const keyNames = Object.keys(keys);
-  const conditionExpression = keyNames.map((key) => `#${key} = :${key}`).join(" and ");
-  const params = {
-    TableName: tableName,
-    KeyConditionExpression: conditionExpression,
-    ExpressionAttributeNames: generateExpressionNames(keyNames),
-    ExpressionAttributeValues: generateExpressionValues(keyNames, keys)
-  };
-  if (indexName) {
-    params.IndexName = indexName;
-  }
-  try {
-    let data = await docClient.send(new QueryCommand(params));
-    let items = data.Items ?? [];
-    while (data.LastEvaluatedKey) {
-      data = await docClient.send(new QueryCommand({
-        ...params,
-        ExclusiveStartKey: data.LastEvaluatedKey
-      }));
-      if (data.Items) {
-        items = items.concat(data.Items);
-      }
-    }
-    return items;
-  } catch (err) {
-    console.log(err);
-    if (err instanceof Error && "statusCode" in err && err.statusCode === 400) {
-      return null;
-    }
-    throw err;
-  }
-}
-async function getRecordByKey(tableName, keys, indexName) {
-  if (indexName) {
-    const records = await getRecordsByKey(tableName, keys, indexName);
-    if (records) {
-      return records[0];
-    } else {
-      return null;
-    }
-  } else {
-    return readRecord(tableName, keys);
-  }
-}
-function generateExpressionNames(keys) {
-  return keys.reduce((acc, key) => ({ ...acc, [`#${key}`]: key }), {});
-}
-function generateExpressionValues(keys, fields) {
-  return keys.reduce((acc, key) => ({ ...acc, [`:${key}`]: fields[key] }), {});
-}
-async function updateRecordByKey(tableName, idKey, fields, conditionExpressions = null, verbose = false) {
-  if (verbose) {
-    console.log("update", tableName, idKey, fields);
-  }
-  const docClient = getDocClient();
-  const idKeyNames = Object.keys(idKey);
-  const fieldsToDelete = Object.keys(fields).filter((f) => fields[f] === undefined);
-  const fieldsToUpdate = Object.keys(fields).filter((k) => !idKeyNames.includes(k) && !fieldsToDelete.includes(k));
-  let data;
-  if (fieldsToDelete.length > 0) {
-    if (verbose) {
-      console.log("delete fields", tableName, fieldsToDelete);
-    }
-    const deleteParams = {
-      TableName: tableName,
-      Key: idKey,
-      ExpressionAttributeNames: generateExpressionNames(fieldsToDelete),
-      UpdateExpression: `REMOVE ${fieldsToDelete.map((f) => `#${f}`).join(", ")}`,
-      ReturnValues: "ALL_NEW"
-    };
-    if (conditionExpressions) {
-      deleteParams.ConditionExpression = conditionExpressions;
-    }
-    data = await docClient.send(new UpdateCommand(deleteParams));
-  }
-  if (fieldsToUpdate.length > 0) {
-    if (verbose) {
-      console.log("update fields", tableName, fieldsToUpdate);
-    }
-    const updateExpressions = fieldsToUpdate.map((key) => `#${key} = :${key}`);
-    const params = {
-      TableName: tableName,
-      Key: idKey,
-      ExpressionAttributeNames: generateExpressionNames(fieldsToUpdate),
-      ExpressionAttributeValues: generateExpressionValues(fieldsToUpdate, fields),
-      UpdateExpression: `SET ${updateExpressions.join(", ")}`,
-      ReturnValues: "ALL_NEW"
-    };
-    if (conditionExpressions) {
-      params.ConditionExpression = conditionExpressions;
-    }
-    data = await docClient.send(new UpdateCommand(params));
-  }
-  return data?.Attributes;
-}
-async function batchDeleteRecords(tableName, keys) {
-  const docClient = getDocClient();
-  for (let start = 0;start < keys.length; start += 25) {
-    const slice = keys.slice(start, start + 25);
-    await docClient.send(new BatchWriteCommand({
-      RequestItems: {
-        [tableName]: slice.map((key) => {
-          return { DeleteRequest: { Key: key } };
-        })
-      }
-    }));
-  }
-}
-function getKeyName(keySchema, type) {
-  const key = keySchema.find((k) => k.KeyType === type);
-  return key?.AttributeName;
-}
-function getIndexKeyName(globalSecondaryIndexes, indexName, type) {
-  const idx = globalSecondaryIndexes.find((i) => i.IndexName === indexName);
-  return idx?.KeySchema && getKeyName(idx.KeySchema, type);
-}
-async function deleteRecordsByHashKey(tableName, indexName, hashKeyValue, verbose = false) {
-  const docClient = getDocClient();
-  const meta = await getDynamoDB().send(new DescribeTableCommand({ TableName: tableName }));
-  if (!meta.Table) {
-    throw new Error(`cannot find table ${tableName}`);
-  }
-  if (indexName && !meta.Table.GlobalSecondaryIndexes) {
-    throw new Error(`cannot find global secondary indexes for table ${tableName}`);
-  }
-  if (!meta.Table.KeySchema) {
-    throw new Error(`cannot find key schema for table ${tableName}`);
-  }
-  const hashKeyName = indexName ? getIndexKeyName(meta.Table.GlobalSecondaryIndexes, indexName, "HASH") : getKeyName(meta.Table.KeySchema, "HASH");
-  if (!hashKeyName) {
-    throw new Error(`cannot find hash key name for table ${tableName}`);
-  }
-  const mainHashKeyName = getKeyName(meta.Table.KeySchema, "HASH");
-  if (!mainHashKeyName) {
-    throw new Error(`cannot find main hash key name for table ${tableName}`);
-  }
-  const mainRangeKeyName = getKeyName(meta.Table.KeySchema, "RANGE");
-  if (!mainRangeKeyName) {
-    throw new Error(`cannot find main range key name for table ${tableName}`);
-  }
-  let totalDeleted = 0;
-  const params = {
-    TableName: tableName,
-    KeyConditionExpression: "#hashKeyName = :hashKeyValue",
-    ExpressionAttributeNames: { "#hashKeyName": hashKeyName },
-    ExpressionAttributeValues: { ":hashKeyValue": hashKeyValue }
-  };
-  if (indexName) {
-    params.IndexName = indexName;
-  }
-  let data = await docClient.send(new QueryCommand(params));
-  if (data.Items) {
-    await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName ? {
-      [mainHashKeyName]: item[mainHashKeyName],
-      [mainRangeKeyName]: item[mainRangeKeyName]
-    } : {
-      [mainHashKeyName]: item[mainHashKeyName]
-    }));
-    totalDeleted += data.Items.length;
-  }
-  while (data.LastEvaluatedKey) {
-    data = await docClient.send(new QueryCommand({
-      ...params,
-      ExclusiveStartKey: data.LastEvaluatedKey
-    }));
-    if (data.Items) {
-      await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName ? {
-        [mainHashKeyName]: item[mainHashKeyName],
-        [mainRangeKeyName]: item[mainRangeKeyName]
-      } : {
-        [mainHashKeyName]: item[mainHashKeyName]
-      }));
-      totalDeleted += data.Items.length;
-    }
-  }
-  if (verbose) {
-    console.log(`successfully delete ${totalDeleted} items`);
-  }
-  return totalDeleted;
-}
-// src/cli.ts
-import path from "path";
-import fs from "fs";
-function getBinaryName() {
-  const binaryNameParts = process.argv[1].split(path.sep);
-  const binaryName = binaryNameParts[binaryNameParts.length - 1];
-  return binaryName;
-}
-function detectSkynetDirectory() {
-  return detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
-}
-function detectWorkingDirectory() {
-  const wd = detectDirectory(process.argv[1], "package.json");
-  const skynetd = detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
-  return wd.slice(skynetd.length + path.sep.length).replace(path.sep, "/");
-}
-function detectDirectory(fullBinPath, sentinel = "package.json") {
-  let parentFolder = path.dirname(fullBinPath);
-  while (parentFolder) {
-    const sentinelPath = path.join(parentFolder, sentinel);
-    if (fs.existsSync(sentinelPath)) {
-      return parentFolder;
-    }
-    const newParentFolder = path.dirname(parentFolder);
-    if (newParentFolder === parentFolder) {
-      break;
-    }
-    parentFolder = newParentFolder;
-  }
-  throw new Error("Cannot detect current working directory");
-}
-function detectBin() {
-  const wd = detectDirectory(process.argv[1], "package.json");
-  return process.argv[1].slice(wd.length + path.sep.length).replace(path.sep, "/");
-}
-// src/date.ts
-var MS_IN_A_DAY = 3600 * 24 * 1000;
-function getDateOnly(date) {
-  return new Date(date).toISOString().split("T")[0];
-}
-function findDateAfter(date, n) {
-  const d = new Date(date);
-  const after = new Date(d.getTime() + MS_IN_A_DAY * n);
-  return getDateOnly(after);
-}
-function daysInRange(from, to) {
-  const fromTime = new Date(from).getTime();
-  const toTime = new Date(to).getTime();
-  if (fromTime > toTime) {
-    throw new Error(`range to date couldn't be earlier than range from date`);
-  }
-  const daysBetween = Math.floor((toTime - fromTime) / MS_IN_A_DAY);
-  const dates = [getDateOnly(new Date(fromTime))];
-  for (let i = 1;i <= daysBetween; i += 1) {
-    dates.push(getDateOnly(new Date(fromTime + i * MS_IN_A_DAY)));
-  }
-  return dates;
-}
-function dateRange(from, to, step) {
-  const days = daysInRange(from, to);
-  const windows = arrayGroup(days, step);
-  return windows.map((w) => [w[0], w[w.length - 1]]);
-}
-// src/indexer.ts
-import meow from "meow";
-var STATE_TABLE_NAME = "skynet-" + getEnvironment() + "-indexer-state";
-async function getIndexerLatestId(name, selectorFlags) {
-  const record = await getRecordByKey(STATE_TABLE_NAME, {
-    name: `${name}Since(${toSelectorString(selectorFlags)})`
-  });
-  return record?.value;
-}
-async function getIndexerValidatedId(name, selectorFlags) {
-  const record = await getRecordByKey(STATE_TABLE_NAME, {
-    name: `${name}Validate(${toSelectorString(selectorFlags)})`
-  });
-  if (record) {
-    return record.value;
-  }
-  return;
-}
-function increaseId(type, currentId, n) {
-  if (type === "date") {
-    if (typeof currentId !== "string") {
-      throw new Error("invalid type for date id");
-    }
-    return findDateAfter(currentId, n);
-  }
-  if (typeof currentId !== "number") {
-    throw new Error("Invalid type for numeric id");
-  }
-  return currentId + n;
-}
-function createModeIndexerApp({
-  binaryName,
-  name,
-  selector = {},
-  build,
-  buildBatchSize = 1,
-  buildConcurrency = 1,
-  validate,
-  validateBatchSize = 1,
-  validateConcurrency = 1,
-  maxRetry = 2,
-  state
-}) {
-  const defaultState = {
-    type: "block",
-    getMinId: async () => 1,
-    getMaxId: async () => {
-      throw new Error("must implement getMaxId");
-    }
-  };
-  const finalState = {
-    ...defaultState,
-    ...state
-  };
-  function range2(from, to, step) {
-    if (typeof from === "string" && typeof to === "string") {
-      if (finalState.type === "date") {
-        return dateRange(from, to, step);
-      }
-      throw new Error("Invalid type for numeric range");
-    }
-    if (typeof from === "number" && typeof to === "number") {
-      return range(from, to, step);
-    }
-    throw new Error("Invalid type for range");
-  }
-  function fillRange2(from, to) {
-    if (typeof from === "string" && typeof to === "string") {
-      if (finalState.type === "date") {
-        return daysInRange(from, to);
-      }
-      throw new Error("Invalid type for numeric range");
-    }
-    if (typeof from === "number" && typeof to === "number") {
-      return fillRange(from, to);
-    }
-    throw new Error("Invalid type for range");
-  }
-  function offsetRange(from, to) {
-    return fillRange2(from, to).length;
-  }
-  async function runMode(flags) {
-    const { mode, from: fromUntyped, to: toUntyped, status, verbose: verboseUntyped, ...untypeSelectorFlags } = flags;
-    const from = fromUntyped;
-    const to = toUntyped;
-    const verbose = verboseUntyped;
-    const selectorFlags = untypeSelectorFlags;
-    if (status) {
-      const stateItem = await getRecordByKey(STATE_TABLE_NAME, {
-        name: `${name}RebuildState(${toSelectorString(selectorFlags)})`
-      });
-      const fromItem = await getRecordByKey(STATE_TABLE_NAME, {
-        name: `${name}Since(${toSelectorString(selectorFlags)})`
-      });
-      const validateItem = await getRecordByKey(STATE_TABLE_NAME, {
-        name: `${name}Validate(${toSelectorString(selectorFlags)})`
-      });
-      inline.log(`RebuildState=${stateItem?.value} Since=${fromItem?.value} Validated=${validateItem?.value}`);
-      process.exit(0);
-    }
-    inline.log(`[MODE INDEXER] mode=${mode}, env=${getEnvironment()}, ${toSelectorString(selectorFlags, ", ")}`);
-    if (mode === "reset") {
-      await runReset(selectorFlags);
-    } else if (mode === "rebuild") {
-      const rebuildFrom = from || await finalState.getMinId(selectorFlags);
-      const rebuildTo = to || await finalState.getMaxId(selectorFlags);
-      await runReset(selectorFlags);
-      await runRebuild(selectorFlags, rebuildFrom, rebuildTo, verbose);
-    } else if (mode === "resume-rebuild") {
-      const previousRebuildEnds = await getIndexerLatestId(name, selectorFlags);
-      const rebuildFrom = from || previousRebuildEnds !== undefined && increaseId(finalState.type, previousRebuildEnds, 1) || await finalState.getMinId(selectorFlags);
-      const rebuildTo = to || await finalState.getMaxId(selectorFlags);
-      await runRebuild(selectorFlags, rebuildFrom, rebuildTo, verbose);
-    } else if (mode === "validate" || mode === "validation") {
-      const previousRebuildEnds = await getIndexerLatestId(name, selectorFlags);
-      if (!previousRebuildEnds) {
-        inline.log(`[MODE INDEXER] cannot validate without a successful rebuild`);
-        process.exit(0);
-      }
-      const previousValidatedTo = await getIndexerValidatedId(name, selectorFlags);
-      const validateFrom = from || previousValidatedTo || await finalState.getMinId(selectorFlags);
-      const validateTo = to || previousRebuildEnds;
-      const shouldSaveState = !to;
-      await runValidate(selectorFlags, validateFrom, validateTo, shouldSaveState, verbose);
-    } else if (mode === "one") {
-      if (to) {
-        inline.log("[MODE INDEXER] one mode ignores --to option. you may want to use range mode instead");
-      }
-      if (!from) {
-        inline.log(`[MODE INDEXER] must provide --from option for one mode`);
-        process.exit(1);
-      }
-      await runRange(selectorFlags, from, from, verbose);
-    } else if (mode === "range") {
-      if (!from || !to) {
-        inline.log(`[MODE INDEXER] must provide --from and --to option for range mode`);
-        process.exit(1);
-      }
-      await runRange(selectorFlags, from, to, verbose);
-    } else {
-      const stateItem = await getRecordByKey(STATE_TABLE_NAME, {
-        name: `${name}RebuildState(${toSelectorString(selectorFlags)})`
-      });
-      if (!stateItem || stateItem.value !== "succeed") {
-        inline.log("[MODE INDEXER] skip because rebuild hasn't done yet");
-        process.exit(0);
-      }
-      const latestId = await getIndexerLatestId(name, selectorFlags);
-      if (!latestId) {
-        throw new Error(`[MODE INDEXER] cannot find the latest ${finalState.type}`);
-      }
-      const deltaFrom = increaseId(finalState.type, latestId, 1);
-      const deltaTo = await state.getMaxId(selectorFlags);
-      await runDelta(selectorFlags, deltaFrom, deltaTo, verbose);
-    }
-  }
-  async function runRange(selectorFlags, from, to, verbose) {
-    const startTime = Date.now();
-    inline.log(`[MODE INDEXER] building range, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${buildBatchSize}, concurrency=${buildConcurrency}`);
-    const failedIds = await execBuild(selectorFlags, from, to, verbose, false);
-    if (failedIds.length > 0) {
-      inline.log(`[MODE INDEXER] built with some failed ${finalState.type}`, failedIds);
-      process.exit(1);
-    } else {
-      inline.log(`[MODE INDEXER] built successfully in ${Date.now() - startTime}ms`);
-      process.exit(0);
-    }
-  }
-  async function runValidate(selectorFlags, from, to, shouldSaveState, verbose) {
-    if (!validate) {
-      inline.log(`[MODE INDEXER] the indexer doesn't support validate mode, validate function not implemented`);
-      process.exit(1);
-    }
-    const startTime = Date.now();
-    inline.log(`[MODE INDEXER] validating, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${validateBatchSize}, concurrency=${validateConcurrency}`);
-    const windows = range2(from, to, validateBatchSize * validateConcurrency);
-    inline.log(`[MODE INDEXER] from=${from}, to=${to}, batchSize=${validateBatchSize}, concurrency=${validateConcurrency}`);
-    for (const [windowStart, windowEnd] of windows) {
-      inline.log(`[MODE INDEXER] validating window ${windowStart}~${windowEnd}, concurrency=${validateConcurrency}`);
-      const batches = range2(windowStart, windowEnd, validateBatchSize);
-      await Promise.all(batches.map(async ([batchStart, batchEnd]) => {
-        const result = await exponentialRetry(async () => {
-          try {
-            await validate({
-              ...selectorFlags,
-              from: batchStart,
-              to: batchEnd,
-              verbose
-            });
-            return true;
-          } catch (err) {
-            inline.error(`got error in validation`, err);
-            return false;
-          }
-        }, {
-          maxRetry,
-          test: (r) => r,
-          verbose
-        });
-        if (!result) {
-          throw new Error(`Terminate validation due to critical errors, from=${batchStart}, to=${batchEnd}`);
-        }
-      }));
-      if (shouldSaveState) {
-        await createRecord(STATE_TABLE_NAME, {
-          name: `${name}Validate(${toSelectorString(selectorFlags)})`,
-          value: to
-        });
-        if (verbose) {
-          inline.log(`[MODE INDEXER] updated processed ${finalState.type} to ${windowEnd}`);
-        }
-      }
-    }
-    inline.log(`[MODE INDEXER] validated ${offsetRange(from, to)} ${finalState.type} successfully in ${Date.now() - startTime}ms`);
-  }
-  async function execBuild(selectorFlags, from, to, verbose, shouldSaveState = false) {
-    let failedIds = [];
-    const windows = range2(from, to, buildBatchSize * buildConcurrency);
-    for (const [windowStart, windowEnd] of windows) {
-      inline.log(`[MODE INDEXER] building window ${windowStart}~${windowEnd}, concurrency = ${buildConcurrency}`);
-      const batches = range2(windowStart, windowEnd, buildBatchSize);
-      const batchResults = await Promise.all(batches.map(async ([batchStart, batchEnd]) => await exponentialRetry(async () => {
-        try {
-          const ids = await build({
-            ...selectorFlags,
-            from: batchStart,
-            to: batchEnd,
-            verbose
-          });
-          if (ids && ids.length > 0) {
-            return ids;
-          } else {
-            return false;
-          }
-        } catch (err) {
-          inline.error(`[MODE INDEXER] got error in build`, err);
-          return fillRange2(batchStart, batchEnd);
-        }
-      }, {
-        maxRetry,
-        test: (r) => !r,
-        verbose
-      })));
-      if (shouldSaveState) {
-        await createRecord(STATE_TABLE_NAME, {
-          name: `${name}Since(${toSelectorString(selectorFlags)})`,
-          value: windowEnd
-        });
-        if (verbose) {
-          inline.log(`[MODE INDEXER] updated processed ${finalState.type} to ${windowEnd}`);
-        }
-      }
-      batchResults.forEach((ids) => {
-        if (ids) {
-          failedIds = failedIds.concat(ids);
-        }
-      });
-    }
-    failedIds.sort();
-    return failedIds;
-  }
-  async function runRebuild(selectorFlags, from, to, verbose) {
-    const startTime = Date.now();
-    inline.log(`[MODE INDEXER] rebuilding, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${buildBatchSize}, concurrency=${buildConcurrency}`);
-    await createRecord(STATE_TABLE_NAME, {
-      name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
-      value: "running"
-    });
-    const failedIds = await execBuild(selectorFlags, from, to, verbose, true);
-    await createRecord(STATE_TABLE_NAME, {
-      name: `${name}Since(${toSelectorString(selectorFlags)})`,
-      value: to
-    });
-    await createRecord(STATE_TABLE_NAME, {
-      name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
-      value: "succeed"
-    });
-    if (failedIds.length > 0) {
-      inline.log(`[MODE INDEXER] built ${offsetRange(from, to)} ${finalState.type}(s) with some failed ${finalState.type}`, failedIds);
-      process.exit(1);
-    } else {
-      inline.log(`[MODE INDEXER] built ${offsetRange(from, to)} ${finalState.type}(s) successfully in ${Date.now() - startTime}ms`);
-      process.exit(0);
-    }
-  }
-  async function runDelta(selectorFlags, from, to, verbose) {
-    const startTime = Date.now();
-    if (to < from) {
-      inline.log(`[MODE INDEXER] skip delta, there're no more items need to be processed, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}`);
-      return;
-    }
-    inline.log(`[MODE INDEXER] starting delta, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${buildBatchSize}, concurrency=${buildConcurrency}`);
-    try {
-      const failedIds = await execBuild(selectorFlags, from, to, verbose, true);
-      if (failedIds.length > 0) {
-        inline.log("[MODE INDEXER] built with some failed txs", failedIds);
-        await createRecord(STATE_TABLE_NAME, {
-          name: `${name}DeltaState(${toSelectorString(selectorFlags)})`,
-          value: "failed"
-        });
-        await createRecord(STATE_TABLE_NAME, {
-          name: `${name}Since(${toSelectorString(selectorFlags)})`,
-          value: to < failedIds[0] ? to : failedIds[0]
-        });
-        process.exit(1);
-      } else {
-        await createRecord(STATE_TABLE_NAME, {
-          name: `${name}DeltaState(${toSelectorString(selectorFlags)})`,
-          value: "succeed"
-        });
-        await createRecord(STATE_TABLE_NAME, {
-          name: `${name}Since(${toSelectorString(selectorFlags)})`,
-          value: to
-        });
-        inline.log(`[MODE INDEXER] built successfully in ${Date.now() - startTime}ms`);
-        process.exit(0);
-      }
-    } catch (err) {
-      inline.error("[MODE INDEXER] delta build failed", from, to, err);
-      process.exit(1);
-    }
-  }
-  async function runReset(selectorFlags) {
-    const startTime = Date.now();
-    inline.log(`[MODE INDEXER] starting reset, ${toSelectorString(selectorFlags, ", ")}`);
-    inline.log("[MODE INDEXER] reset state", STATE_TABLE_NAME);
-    await createRecord(STATE_TABLE_NAME, {
-      name: `${name}Since(${toSelectorString(selectorFlags)})`,
-      value: 0
-    });
-    await createRecord(STATE_TABLE_NAME, {
-      name: `${name}Validate(${toSelectorString(selectorFlags)})`,
-      value: 0
-    });
-    await createRecord(STATE_TABLE_NAME, {
-      name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
-      value: "init"
-    });
-    inline.log(`[MODE INDEXER] reset successfully in ${Date.now() - startTime}ms`);
-  }
-  async function run() {
-    if (!binaryName) {
-      binaryName = getBinaryName();
-    }
-    const cli = meow(`
-        Usage
-
-          $ ${binaryName} <options>
-
-        Options
-${selector ? getSelectorDesc(selector) : ""}
-          --mode          could be delta/rebuild/resume-rebuild/validate/one/range/reset
-          --from          min ${finalState.type} to build
-          --to            max ${finalState.type} to build
-          --status        print status of indexer and exit
-          --verbose       Output debug messages
-      `, {
-      importMeta: import.meta,
-      description: false,
-      flags: {
-        ...getSelectorFlags(selector),
-        mode: {
-          type: "string",
-          default: "delta"
-        },
-        from: {
-          aliases: ["since"],
-          type: "string"
-        },
-        to: {
-          aliases: ["until"],
-          type: "string"
-        },
-        status: {
-          type: "boolean",
-          default: false
-        },
-        verbose: {
-          type: "boolean",
-          default: false
-        }
-      }
-    });
-    try {
-      return runMode(cli.flags);
-    } catch (err) {
-      inline.error(err);
-      process.exit(1);
-    }
-  }
-  return { run };
-}
-function createIndexerApp({
-  binaryName,
-  selector = {},
-  build,
-  maxRetry = 2
-}) {
-  async function run() {
-    if (!binaryName) {
-      binaryName = getBinaryName();
-    }
-    const cli = meow(`
-        Usage
-          $ ${binaryName} <options>
-
-        Options
-${selector ? getSelectorDesc(selector) : ""}
-          --verbose       Output debug messages
-      `, {
-      importMeta: import.meta,
-      description: false,
-      flags: {
-        ...getSelectorFlags(selector),
-        verbose: {
-          type: "boolean",
-          default: false
-        }
-      }
-    });
-    async function runBuild(flags) {
-      const { verbose: untypedVerbose, ...untypedSelectorFlags } = flags;
-      const verbose = untypedVerbose;
-      const selectorFlags = untypedSelectorFlags;
-      const startTime = Date.now();
-      if (Object.keys(selectorFlags).length > 0) {
-        inline.log(`[INDEXER] starting build, ${toSelectorString(selectorFlags, ", ")}`);
-      } else {
-        inline.log(`[INDEXER] starting build`);
-      }
-      const result = await exponentialRetry(async () => {
-        try {
-          await build(flags);
-          return true;
-        } catch (err) {
-          inline.log(`[INDEXER] got error in build`, err);
-          return false;
-        }
-      }, {
-        maxRetry,
-        test: (r) => r,
-        verbose
-      });
-      if (!result) {
-        throw new Error(`[INDEXER] Build failed due to critical errors`);
-      }
-      inline.log(`[INDEXER] build successfully in ${Date.now() - startTime}ms`);
-    }
-    return runBuild(cli.flags).catch((err) => {
-      inline.error(err);
-      process.exit(1);
-    });
-  }
-  return { run };
-}
-export {
-  increaseId,
-  createModeIndexerApp,
-  createIndexerApp
-};