ponder 0.9.2 → 0.9.4-debug.1

package/dist/chunk-6AOFLZJ4.js

@@ -0,0 +1,1692 @@
+import {
+  createQueue
+} from "./chunk-MJKRYIBO.js";
+import {
+  onchain
+} from "./chunk-K2TLRLX3.js";
+
+// src/drizzle/index.ts
+import { getTableColumns, getTableName, is as is2 } from "drizzle-orm";
+import { PgTable as PgTable2, getTableConfig as getTableConfig2 } from "drizzle-orm/pg-core";
+
+// src/drizzle/kit/index.ts
+import { SQL, is } from "drizzle-orm";
+import { CasingCache, toCamelCase, toSnakeCase } from "drizzle-orm/casing";
+import {
+  PgDialect,
+  PgEnumColumn,
+  PgMaterializedView,
+  PgSchema,
+  PgTable,
+  PgView,
+  getTableConfig,
+  integer,
+  isPgEnum,
+  isPgSequence,
+  pgTable,
+  serial,
+  varchar
+} from "drizzle-orm/pg-core";
+var sqlToReorgTableName = (tableName) => `_reorg__${tableName}`;
+var getSql = (schema) => {
+  const { tables, enums, schemas } = prepareFromExports(schema);
+  const json = generatePgSnapshot(tables, enums, schemas, "snake_case");
+  const squashed = squashPgScheme(json);
+  const jsonCreateIndexesForCreatedTables = Object.values(
+    squashed.tables
+  ).flatMap((it) => {
+    return preparePgCreateIndexesJson(it.name, it.schema, it.indexes);
+  });
+  const jsonCreateEnums = Object.values(squashed.enums).map((it) => {
+    return prepareCreateEnumJson(it.name, it.schema, it.values);
+  }) ?? [];
+  const jsonCreateTables = Object.values(squashed.tables).map((it) => {
+    return preparePgCreateTableJson(it, json);
+  });
+  const fromJson = (statements) => statements.flatMap((statement) => {
+    const filtered = convertors.filter((it) => {
+      return it.can(statement, "postgresql");
+    });
+    const convertor = filtered.length === 1 ? filtered[0] : void 0;
+    if (!convertor) {
+      return "";
+    }
+    return convertor.convert(statement);
+  }).filter((it) => it !== "");
+  const combinedTables = jsonCreateTables.flatMap((statement) => [
+    statement,
+    createReorgTableStatement(statement)
+  ]);
+  return {
+    tables: {
+      sql: fromJson(combinedTables),
+      json: combinedTables
+    },
+    enums: { sql: fromJson(jsonCreateEnums), json: jsonCreateEnums },
+    indexes: {
+      sql: fromJson(jsonCreateIndexesForCreatedTables),
+      json: jsonCreateIndexesForCreatedTables
+    }
+  };
+};
+var createReorgTableStatement = (statement) => {
+  const reorgStatement = structuredClone(statement);
+  reorgStatement.compositePkName = void 0;
+  reorgStatement.compositePKs = [];
+  for (const column of reorgStatement.columns) {
+    column.primaryKey = false;
+  }
+  const reorgColumns = Object.values(
+    squashPgScheme(
+      generatePgSnapshot(
+        [
+          pgTable("", {
+            operation_id: serial().notNull().primaryKey(),
+            operation: integer().notNull(),
+            checkpoint: varchar({
+              length: 75
+            }).notNull()
+          })
+        ],
+        [],
+        [],
+        "snake_case"
+      )
+    ).tables
+    //@ts-ignore
+  )[0].columns;
+  reorgStatement.columns.push(...Object.values(reorgColumns));
+  reorgStatement.tableName = sqlToReorgTableName(reorgStatement.tableName);
+  return reorgStatement;
+};
+var PgSquasher = {
+  squashIdx: (idx) => {
+    return `${idx.name};${idx.columns.map(
+      (c) => `${c.expression}--${c.isExpression}--${c.asc}--${c.nulls}--${c.opclass && ""}`
+    ).join(
+      ",,"
+    )};${idx.isUnique};${idx.concurrently};${idx.method};${idx.where};${JSON.stringify(idx.with)}`;
+  },
+  unsquashIdx: (input) => {
+    const [
+      name,
+      columnsString,
+      isUnique,
+      concurrently,
+      method,
+      where,
+      idxWith
+    ] = input.split(";");
+    const columnString = columnsString.split(",,");
+    const columns = [];
+    for (const column of columnString) {
+      const [expression, isExpression, asc, nulls, opclass] = column.split("--");
+      columns.push({
+        nulls,
+        isExpression: isExpression === "true",
+        asc: asc === "true",
+        expression,
+        opclass: opclass === "undefined" ? void 0 : opclass
+      });
+    }
+    return {
+      name,
+      columns,
+      isUnique: isUnique === "true",
+      concurrently: concurrently === "true",
+      method,
+      where: where === "undefined" ? void 0 : where,
+      with: !idxWith || idxWith === "undefined" ? void 0 : JSON.parse(idxWith)
+    };
+  },
+  squashPK: (pk) => {
+    return `${pk.columns.join(",")};${pk.name}`;
+  },
+  unsquashPK: (pk) => {
+    const splitted = pk.split(";");
+    return { name: splitted[1], columns: splitted[0].split(",") };
+  }
+};
+var parseType = (schemaPrefix, type) => {
+  const pgNativeTypes = [
+    "uuid",
+    "smallint",
+    "integer",
+    "bigint",
+    "boolean",
+    "text",
+    "varchar",
+    "serial",
+    "bigserial",
+    "decimal",
+    "numeric",
+    "real",
+    "json",
+    "jsonb",
+    "time",
+    "time with time zone",
+    "time without time zone",
+    "time",
+    "timestamp",
+    "timestamp with time zone",
+    "timestamp without time zone",
+    "date",
+    "interval",
+    "bigint",
+    "bigserial",
+    "double precision",
+    "interval year",
+    "interval month",
+    "interval day",
+    "interval hour",
+    "interval minute",
+    "interval second",
+    "interval year to month",
+    "interval day to hour",
+    "interval day to minute",
+    "interval day to second",
+    "interval hour to minute",
+    "interval hour to second",
+    "interval minute to second"
+  ];
+  const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
+  const arrayDefinition = (type.match(arrayDefinitionRegex) ?? []).join("");
+  const withoutArrayDefinition = type.replace(arrayDefinitionRegex, "");
+  return pgNativeTypes.some((it) => type.startsWith(it)) ? `${withoutArrayDefinition}${arrayDefinition}` : `${schemaPrefix}"${withoutArrayDefinition}"${arrayDefinition}`;
+};
+var Convertor = class {
+};
+var PgCreateTableConvertor = class extends Convertor {
+  can(statement, dialect) {
+    return statement.type === "create_table" && dialect === "postgresql";
+  }
+  convert(st) {
+    const { tableName, schema, columns, compositePKs } = st;
+    let statement = "";
+    const name = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+    statement += `CREATE TABLE ${name} (
+`;
+    for (let i = 0; i < columns.length; i++) {
+      const column = columns[i];
+      const primaryKeyStatement = column.primaryKey ? " PRIMARY KEY" : "";
+      const notNullStatement = column.notNull && !column.identity ? " NOT NULL" : "";
+      const defaultStatement = column.default !== void 0 ? ` DEFAULT ${column.default}` : "";
+      const schemaPrefix = column.typeSchema && column.typeSchema !== "public" ? `"${column.typeSchema}".` : "";
+      const type = parseType(schemaPrefix, column.type);
+      statement += `	"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${notNullStatement}`;
+      statement += i === columns.length - 1 ? "" : ",\n";
+    }
+    if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
+      statement += ",\n";
+      const compositePK = PgSquasher.unsquashPK(compositePKs[0]);
+      statement += `	CONSTRAINT "${st.compositePkName}" PRIMARY KEY("${compositePK.columns.join(`","`)}")`;
+    }
+    statement += "\n);";
+    statement += "\n";
+    return statement;
+  }
+};
+var CreateTypeEnumConvertor = class extends Convertor {
+  can(statement) {
+    return statement.type === "create_type_enum";
+  }
+  convert(st) {
+    const { name, values, schema } = st;
+    const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+    let valuesStatement = "(";
+    valuesStatement += values.map((it) => `'${it}'`).join(", ");
+    valuesStatement += ")";
+    const statement = `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
+    return statement;
+  }
+};
+var CreatePgIndexConvertor = class extends Convertor {
+  can(statement, dialect) {
+    return statement.type === "create_index_pg" && dialect === "postgresql";
+  }
+  convert(statement) {
+    const {
+      name,
+      columns,
+      isUnique,
+      concurrently,
+      with: withMap,
+      method,
+      where
+    } = statement.data;
+    const indexPart = isUnique ? "UNIQUE INDEX" : "INDEX";
+    const value = columns.map(
+      (it) => `${it.isExpression ? it.expression : `"${it.expression}"`}${it.opclass ? ` ${it.opclass}` : it.asc ? "" : " DESC"}${it.asc && it.nulls && it.nulls === "last" || it.opclass ? "" : ` NULLS ${it.nulls.toUpperCase()}`}`
+    ).join(",");
+    const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
+    function reverseLogic(mappedWith) {
+      let reversedString = "";
+      for (const key in mappedWith) {
+        if (mappedWith.hasOwnProperty(key)) {
+          reversedString += `${key}=${mappedWith[key]},`;
+        }
+      }
+      reversedString = reversedString.slice(0, -1);
+      return reversedString;
+    }
+    return `CREATE ${indexPart}${concurrently ? " CONCURRENTLY" : ""} IF NOT EXISTS "${name}" ON ${tableNameWithSchema} USING ${method} (${value})${Object.keys(withMap).length !== 0 ? ` WITH (${reverseLogic(withMap)})` : ""}${where ? ` WHERE ${where}` : ""};`;
+  }
+};
+var PgCreateSchemaConvertor = class extends Convertor {
+  can(statement, dialect) {
+    return statement.type === "create_schema" && dialect === "postgresql";
+  }
+  convert(statement) {
+    const { name } = statement;
+    return `CREATE SCHEMA IF NOT EXISTS"${name}";
+`;
+  }
+};
+var convertors = [];
+convertors.push(new PgCreateTableConvertor());
+convertors.push(new CreateTypeEnumConvertor());
+convertors.push(new CreatePgIndexConvertor());
+convertors.push(new PgCreateSchemaConvertor());
+var preparePgCreateTableJson = (table, json) => {
+  const { name, schema, columns, compositePrimaryKeys } = table;
+  const tableKey = `${schema || "public"}.${name}`;
+  const compositePkName = Object.values(compositePrimaryKeys).length > 0 ? json.tables[tableKey].compositePrimaryKeys[`${PgSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name}`].name : "";
+  return {
+    type: "create_table",
+    tableName: name,
+    schema,
+    columns: Object.values(columns),
+    compositePKs: Object.values(compositePrimaryKeys),
+    compositePkName
+  };
+};
+var preparePgCreateIndexesJson = (tableName, schema, indexes) => {
+  return Object.values(indexes).map((indexData) => {
+    return {
+      type: "create_index_pg",
+      tableName,
+      data: PgSquasher.unsquashIdx(indexData),
+      schema
+    };
+  });
+};
+var prepareCreateEnumJson = (name, schema, values) => {
+  return {
+    type: "create_type_enum",
+    name,
+    schema,
+    values
+  };
+};
+var prepareFromExports = (exports) => {
+  const tables = [];
+  const enums = [];
+  const schemas = [];
+  const sequences = [];
+  const views = [];
+  const matViews = [];
+  const i0values = Object.values(exports);
+  i0values.forEach((t) => {
+    if (isPgEnum(t)) {
+      enums.push(t);
+      return;
+    }
+    if (is(t, PgTable)) {
+      tables.push(t);
+    }
+    if (is(t, PgSchema)) {
+      schemas.push(t);
+    }
+    if (is(t, PgView)) {
+      views.push(t);
+    }
+    if (is(t, PgMaterializedView)) {
+      matViews.push(t);
+    }
+    if (isPgSequence(t)) {
+      sequences.push(t);
+    }
+  });
+  return { tables, enums, schemas, sequences, views, matViews };
+};
+function getColumnCasing(column, casing) {
+  if (!column.name)
+    return "";
+  return !column.keyAsName || casing === void 0 ? column.name : casing === "camelCase" ? toCamelCase(column.name) : toSnakeCase(column.name);
+}
+var sqlToStr = (sql2, casing) => {
+  return sql2.toQuery({
+    escapeName: () => {
+      throw new Error("we don't support params for `sql` default values");
+    },
+    escapeParam: () => {
+      throw new Error("we don't support params for `sql` default values");
+    },
+    escapeString: () => {
+      throw new Error("we don't support params for `sql` default values");
+    },
+    casing: new CasingCache(casing)
+  }).sql;
+};
+function isPgArrayType(sqlType) {
+  return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
+}
+function buildArrayString(array, sqlType) {
+  sqlType = sqlType.split("[")[0];
+  const values = array.map((value) => {
+    if (typeof value === "number" || typeof value === "bigint") {
+      return value.toString();
+    } else if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    } else if (Array.isArray(value)) {
+      return buildArrayString(value, sqlType);
+    } else if (value instanceof Date) {
+      if (sqlType === "date") {
+        return `"${value.toISOString().split("T")[0]}"`;
+      } else if (sqlType === "timestamp") {
+        return `"${value.toISOString().replace("T", " ").slice(0, 23)}"`;
+      } else {
+        return `"${value.toISOString()}"`;
+      }
+    } else if (typeof value === "object") {
+      return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
+    }
+    return `"${value}"`;
+  }).join(",");
+  return `{${values}}`;
+}
+var indexName = (tableName, columns) => {
+  return `${tableName}_${columns.join("_")}_index`;
+};
+var generatePgSnapshot = (tables, enums, schemas, casing) => {
+  const dialect = new PgDialect({ casing });
+  const result = {};
+  const indexesInSchema = {};
+  for (const table of tables) {
+    const {
+      name: tableName,
+      columns,
+      indexes,
+      schema,
+      primaryKeys
+    } = getTableConfig(table);
+    const columnsObject = {};
+    const indexesObject = {};
+    const primaryKeysObject = {};
+    columns.forEach((column) => {
+      const name = getColumnCasing(column, casing);
+      const notNull = column.notNull;
+      const primaryKey = column.primary;
+      const sqlTypeLowered = column.getSQLType().toLowerCase();
+      const typeSchema = is(column, PgEnumColumn) ? column.enum.schema || "public" : void 0;
+      const columnToSet = {
+        name,
+        type: column.getSQLType(),
+        typeSchema,
+        primaryKey,
+        notNull
+      };
+      if (column.default !== void 0) {
+        if (is(column.default, SQL)) {
+          columnToSet.default = sqlToStr(column.default, casing);
+        } else {
+          if (typeof column.default === "string") {
+            columnToSet.default = `'${column.default}'`;
+          } else {
+            if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
+              columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
+            } else if (column.default instanceof Date) {
+              if (sqlTypeLowered === "date") {
+                columnToSet.default = `'${column.default.toISOString().split("T")[0]}'`;
+              } else if (sqlTypeLowered === "timestamp") {
+                columnToSet.default = `'${column.default.toISOString().replace("T", " ").slice(0, 23)}'`;
+              } else {
+                columnToSet.default = `'${column.default.toISOString()}'`;
+              }
+            } else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
+              columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
+            } else {
+              columnToSet.default = column.default;
+            }
+          }
+        }
+      }
+      columnsObject[name] = columnToSet;
+    });
+    primaryKeys.map((pk) => {
+      const originalColumnNames = pk.columns.map((c) => c.name);
+      const columnNames = pk.columns.map((c) => getColumnCasing(c, casing));
+      let name = pk.getName();
+      if (casing !== void 0) {
+        for (let i = 0; i < originalColumnNames.length; i++) {
+          name = name.replace(originalColumnNames[i], columnNames[i]);
+        }
+      }
+      primaryKeysObject[name] = {
+        name,
+        columns: columnNames
+      };
+    });
+    indexes.forEach((value) => {
+      const columns2 = value.config.columns;
+      const indexColumnNames = [];
+      columns2.forEach((it) => {
+        const name2 = getColumnCasing(it, casing);
+        indexColumnNames.push(name2);
+      });
+      const name = value.config.name ? value.config.name : indexName(tableName, indexColumnNames);
+      const indexColumns = columns2.map(
+        (it) => {
+          if (is(it, SQL)) {
+            return {
+              expression: dialect.sqlToQuery(it, "indexes").sql,
+              asc: true,
+              isExpression: true,
+              nulls: "last"
+            };
+          } else {
+            it = it;
+            return {
+              expression: getColumnCasing(it, casing),
+              isExpression: false,
+              // @ts-ignore
+              asc: it.indexConfig?.order === "asc",
+              // @ts-ignore
+              nulls: it.indexConfig?.nulls ? (
+                // @ts-ignore
+                it.indexConfig?.nulls
+              ) : (
+                // @ts-ignore
+                it.indexConfig?.order === "desc" ? "first" : "last"
+              ),
+              // @ts-ignore
+              opclass: it.indexConfig?.opClass
+            };
+          }
+        }
+      );
+      if (typeof indexesInSchema[schema ?? "public"] !== "undefined") {
+        indexesInSchema[schema ?? "public"].push(name);
+      } else {
+        indexesInSchema[schema ?? "public"] = [name];
+      }
+      indexesObject[name] = {
+        name,
+        columns: indexColumns,
+        isUnique: value.config.unique ?? false,
+        where: value.config.where ? dialect.sqlToQuery(value.config.where).sql : void 0,
+        concurrently: value.config.concurrently ?? false,
+        method: value.config.method ?? "btree",
+        with: value.config.with ?? {}
+      };
+    });
+    const tableKey = `${schema ?? "public"}.${tableName}`;
+    result[tableKey] = {
+      name: tableName,
+      schema: schema ?? "",
+      columns: columnsObject,
+      indexes: indexesObject,
+      compositePrimaryKeys: primaryKeysObject
+    };
+  }
+  const enumsToReturn = enums.reduce((map, obj) => {
+    const enumSchema = obj.schema || "public";
+    const key = `${enumSchema}.${obj.enumName}`;
+    map[key] = {
+      name: obj.enumName,
+      schema: enumSchema,
+      values: obj.enumValues
+    };
+    return map;
+  }, {});
+  const schemasObject = Object.fromEntries(
+    schemas.filter((it) => {
+      return it.schemaName !== "public";
+    }).map((it) => [it.schemaName, it.schemaName])
+  );
+  return {
+    version: "7",
+    dialect: "postgresql",
+    tables: result,
+    enums: enumsToReturn,
+    schemas: schemasObject
+  };
+};
+var mapValues = (obj, map) => {
+  const result = Object.keys(obj).reduce(
+    (result2, key) => {
+      result2[key] = map(obj[key]);
+      return result2;
+    },
+    {}
+  );
+  return result;
+};
+var squashPgScheme = (json) => {
+  const mappedTables = Object.fromEntries(
+    Object.entries(json.tables).map((it) => {
+      const squashedIndexes = mapValues(it[1].indexes, (index) => {
+        return PgSquasher.squashIdx(index);
+      });
+      const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
+        return PgSquasher.squashPK(pk);
+      });
+      const mappedColumns = Object.fromEntries(
+        Object.entries(it[1].columns).map((it2) => {
+          return [
+            it2[0],
+            {
+              ...it2[1],
+              identity: void 0
+            }
+          ];
+        })
+      );
+      return [
+        it[0],
+        {
+          name: it[1].name,
+          schema: it[1].schema,
+          columns: mappedColumns,
+          indexes: squashedIndexes,
+          compositePrimaryKeys: squashedPKs
+        }
+      ];
+    })
+  );
+  return {
+    version: "7",
+    dialect: json.dialect,
+    tables: mappedTables,
+    enums: json.enums,
+    schemas: json.schemas,
+    views: json.views
+  };
+};
+
+// src/drizzle/index.ts
+var getTableNames = (schema) => {
+  const tableNames = Object.entries(schema).filter(([, table]) => is2(table, PgTable2)).map(([js, table]) => {
+    const sql2 = getTableName(table);
+    return {
+      sql: sql2,
+      reorg: sqlToReorgTableName(sql2),
+      trigger: sqlToReorgTableName(sql2),
+      triggerFn: `operation_reorg__${sql2}()`,
+      js
+    };
+  });
+  return tableNames;
+};
+var getPrimaryKeyColumns = (table) => {
+  const primaryKeys = getTableConfig2(table).primaryKeys;
+  const findJsName = (column) => {
+    const name = column.name;
+    for (const [js, column2] of Object.entries(getTableColumns(table))) {
+      if (column2.name === name)
+        return js;
+    }
+    throw "unreachable";
+  };
+  if (primaryKeys.length > 0) {
+    return primaryKeys[0].columns.map((column) => ({
+      sql: getColumnCasing(column, "snake_case"),
+      js: findJsName(column)
+    }));
+  }
+  const pkColumn = Object.values(getTableColumns(table)).find(
+    (c) => c.primary
+  );
+  return [
+    {
+      sql: getColumnCasing(pkColumn, "snake_case"),
+      js: findJsName(pkColumn)
+    }
+  ];
+};
+
+// src/internal/errors.ts
+var BaseError = class _BaseError extends Error {
+  name = "BaseError";
+  meta = [];
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _BaseError.prototype);
+  }
+};
+function getBaseError(err) {
+  if (err instanceof BaseError)
+    return err;
+  if (err instanceof Error)
+    return new BaseError(err.message);
+  if (typeof err?.message === "string")
+    return new BaseError(err.message);
+  if (typeof err === "string")
+    return new BaseError(err);
+  return new BaseError("unknown error");
+}
+var BuildError = class _BuildError extends BaseError {
+  name = "BuildError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _BuildError.prototype);
+  }
+};
+var NonRetryableError = class _NonRetryableError extends BaseError {
+  name = "NonRetryableError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _NonRetryableError.prototype);
+  }
+};
+var UniqueConstraintError = class _UniqueConstraintError extends NonRetryableError {
+  name = "UniqueConstraintError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _UniqueConstraintError.prototype);
+  }
+};
+var NotNullConstraintError = class _NotNullConstraintError extends NonRetryableError {
+  name = "NotNullConstraintError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _NotNullConstraintError.prototype);
+  }
+};
+var RecordNotFoundError = class _RecordNotFoundError extends NonRetryableError {
+  name = "RecordNotFoundError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _RecordNotFoundError.prototype);
+  }
+};
+var CheckConstraintError = class _CheckConstraintError extends NonRetryableError {
+  name = "CheckConstraintError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _CheckConstraintError.prototype);
+  }
+};
+var InvalidStoreMethodError = class _InvalidStoreMethodError extends NonRetryableError {
+  name = "InvalidStoreMethodError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _InvalidStoreMethodError.prototype);
+  }
+};
+var UndefinedTableError = class _UndefinedTableError extends NonRetryableError {
+  name = "UndefinedTableError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _UndefinedTableError.prototype);
+  }
+};
+var BigIntSerializationError = class _BigIntSerializationError extends NonRetryableError {
+  name = "BigIntSerializationError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _BigIntSerializationError.prototype);
+  }
+};
+var FlushError = class _FlushError extends NonRetryableError {
+  name = "FlushError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _FlushError.prototype);
+  }
+};
+var ShutdownError = class _ShutdownError extends NonRetryableError {
+  name = "ShutdownError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _ShutdownError.prototype);
+  }
+};
+
+// src/utils/print.ts
+function prettyPrint(args) {
+  if (args === void 0)
+    return "(undefined)";
+  const entries = Object.entries(args).map(([key, value]) => {
+    if (value === void 0)
+      return null;
+    const trimmedValue = typeof value === "string" && value.length > 80 ? value.slice(0, 80).concat("...") : value;
+    return [key, trimmedValue];
+  }).filter(Boolean);
+  if (entries.length === 0)
+    return "  (empty object)";
+  const maxLength = entries.reduce(
+    (acc, [key]) => Math.max(acc, key.length),
+    0
+  );
+  return entries.map(([key, value]) => `  ${`${key}`.padEnd(maxLength + 1)}  ${value}`).join("\n");
+}
+
+// src/indexing-store/historical.ts
+import {
+  and,
+  eq,
+  getTableColumns as getTableColumns2,
+  getTableName as getTableName2,
+  sql
+} from "drizzle-orm";
+import { getTableConfig as getTableConfig3 } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/pg-proxy";
+
+// src/indexing-store/index.ts
+var parseSqlError = (e) => {
+  let error = getBaseError(e);
+  if (error?.message?.includes("violates not-null constraint")) {
+    error = new NotNullConstraintError(error.message);
+  } else if (error?.message?.includes("violates unique constraint")) {
+    error = new UniqueConstraintError(error.message);
+  } else if (error?.message.includes("violates check constraint")) {
+    error = new CheckConstraintError(error.message);
+  } else if (error?.message?.includes("Do not know how to serialize a BigInt")) {
+    error = new BigIntSerializationError(error.message);
+    error.meta.push(
+      "Hint:\n  The JSON column type does not support BigInt values. Use the replaceBigInts() helper function before inserting into the database. Docs: https://ponder.sh/docs/utilities/replace-bigints"
+    );
+  }
+  return error;
+};
+
+// src/indexing-store/historical.ts
+var checkOnchainTable = (table, method) => {
+  if (table === void 0)
+    throw new UndefinedTableError(
+      `Table object passed to db.${method}() is undefined`
+    );
+  if (onchain in table)
+    return;
+  throw new InvalidStoreMethodError(
+    method === "find" ? `db.find() can only be used with onchain tables, and '${getTableConfig3(table).name}' is an offchain table.` : `Indexing functions can only write to onchain tables, and '${getTableConfig3(table).name}' is an offchain table.`
+  );
+};
+var hasEmptyValue = (column) => {
+  return column.hasDefault;
+};
+var getEmptyValue = (column, type) => {
+  if (type === 1 /* UPDATE */ && column.onUpdateFn) {
+    return column.onUpdateFn();
+  }
+  if (column.default !== void 0)
+    return column.default;
+  if (column.defaultFn !== void 0)
+    return column.defaultFn();
+  if (column.onUpdateFn !== void 0)
+    return column.onUpdateFn();
+  return void 0;
+};
+var normalizeColumn = (column, value, type) => {
+  if (value === void 0) {
+    if (hasEmptyValue(column))
+      return getEmptyValue(column, type);
+    return null;
+  }
+  if (column.mapToDriverValue === void 0)
+    return value;
+  try {
+    return column.mapFromDriverValue(column.mapToDriverValue(value));
+  } catch (e) {
+    if (e?.message?.includes("Do not know how to serialize a BigInt")) {
+      const error = new BigIntSerializationError(e.message);
+      error.meta.push(
+        "Hint:\n  The JSON column type does not support BigInt values. Use the replaceBigInts() helper function before inserting into the database. Docs: https://ponder.sh/docs/utilities/replace-bigints"
+      );
+      throw error;
+    }
+  }
+};
+var createHistoricalIndexingStore = ({
+  common,
+  schemaBuild: { schema },
+  database,
+  isDatabaseEmpty
+}) => {
+  const queue = createQueue({
+    browser: false,
+    initialStart: true,
+    concurrency: 1,
+    worker: (fn) => {
+      return fn();
+    }
+  });
+  const primaryKeysCache = /* @__PURE__ */ new Map();
+  const cache = /* @__PURE__ */ new Map();
+  for (const tableName of getTableNames(schema)) {
+    primaryKeysCache.set(
+      schema[tableName.js],
+      getPrimaryKeyColumns(schema[tableName.js])
+    );
+    cache.set(schema[tableName.js], /* @__PURE__ */ new Map());
+  }
+  const getCacheKey = (table, row) => {
+    const primaryKeys = primaryKeysCache.get(table);
+    return primaryKeys.map((pk) => normalizeColumn(table[pk.js], row[pk.js])).join("_");
+  };
+  const getCacheEntry = (table, row) => {
+    return cache.get(table).get(getCacheKey(table, row));
+  };
+  const setCacheEntry = (table, userRow, entryType, existingRow) => {
+    let row = structuredClone(userRow);
+    if (existingRow) {
+      for (const [key, value] of Object.entries(row)) {
+        existingRow[key] = value;
+      }
+      existingRow = normalizeRow(table, existingRow, entryType);
+      const bytes = getBytes(existingRow);
+      cacheBytes += bytes;
+      cache.get(table).set(getCacheKey(table, existingRow), {
+        type: entryType,
+        row: existingRow,
+        operationIndex: totalCacheOps++,
+        bytes
+      });
+      return structuredClone(existingRow);
+    } else {
+      row = normalizeRow(table, row, entryType);
+      const bytes = getBytes(row);
+      cacheBytes += bytes;
+      cache.get(table).set(getCacheKey(table, row), {
+        type: entryType,
+        bytes,
+        operationIndex: totalCacheOps++,
+        row
+      });
+      return structuredClone(row);
+    }
+  };
+  const deleteCacheEntry = (table, row) => {
+    const entry = getCacheEntry(table, row);
+    if (entry) {
+      cacheBytes -= entry.bytes;
+    }
+    return cache.get(table).delete(getCacheKey(table, row));
+  };
+  const normalizeRow = (table, row, type) => {
+    for (const [columnName, column] of Object.entries(getTableColumns2(table))) {
+      if (type === 0 /* INSERT */ && (row[columnName] === void 0 || row[columnName] === null) && column.notNull && hasEmptyValue(column) === false) {
+        const error = new NotNullConstraintError(
+          `Column '${getTableName2(table)}.${columnName}' violates not-null constraint.`
+        );
+        error.meta.push(
+          `db.${type === 0 /* INSERT */ ? "insert" : "update"} arguments:
+${prettyPrint(row)}`
+        );
+        throw error;
+      }
+      row[columnName] = normalizeColumn(column, row[columnName], type);
+    }
+    return row;
+  };
+  const getBytes = (value) => {
+    let size = 13;
+    if (typeof value === "number") {
+      size += 8;
+    } else if (typeof value === "string") {
+      size += 2 * value.length;
+    } else if (typeof value === "boolean") {
+      size += 4;
+    } else if (typeof value === "bigint") {
+      size += 48;
+    } else if (value === null || value === void 0) {
+      size += 8;
+    } else if (Array.isArray(value)) {
+      for (const e of value) {
+        size += getBytes(e);
+      }
+    } else {
+      for (const col of Object.values(value)) {
+        size += getBytes(col);
+      }
+    }
+    return size;
+  };
+  let cacheBytes = 0;
+  let totalCacheOps = 0;
+  const maxBytes = common.options.indexingCacheMaxBytes;
+  common.logger.debug({
+    service: "indexing",
+    msg: `Using a ${Math.round(maxBytes / (1024 * 1024))} MB indexing cache`
+  });
+  const getWhereCondition = (table, key) => {
+    primaryKeysCache.get(table);
+    const conditions = [];
+    for (const { js } of primaryKeysCache.get(table)) {
+      conditions.push(eq(table[js], key[js]));
+    }
+    return and(...conditions);
+  };
+  const find = (table, key) => {
+    return database.qb.drizzle.select().from(table).where(getWhereCondition(table, key)).then((res) => res.length === 0 ? null : res[0]);
+  };
+  const indexingStore = {
+    // @ts-ignore
+    find: (table, key) => queue.add(
+      () => database.wrap(
+        { method: `${getTableName2(table) ?? "unknown"}.find()` },
+        async () => {
+          checkOnchainTable(table, "find");
+          const entry = getCacheEntry(table, key);
+          if (entry) {
+            getCacheEntry(table, key).operationIndex = totalCacheOps++;
+            return entry.row;
+          } else {
+            if (isDatabaseEmpty)
+              return null;
+            const row = await find(table, key);
+            const bytes = getBytes(row);
+            cacheBytes += bytes;
+            cache.get(table).set(getCacheKey(table, key), {
+              type: 2 /* FIND */,
+              bytes,
+              operationIndex: totalCacheOps++,
+              row
+            });
+            return find(table, key);
+          }
+        }
+      )
+    ),
+    // @ts-ignore
+    insert(table) {
+      return {
+        values: (values) => {
+          const inner = {
+            onConflictDoNothing: () => queue.add(
+              () => database.wrap(
+                {
+                  method: `${getTableName2(table) ?? "unknown"}.insert()`
+                },
+                async () => {
+                  checkOnchainTable(table, "insert");
+                  if (Array.isArray(values)) {
+                    const rows = [];
+                    for (const value of values) {
+                      const entry = getCacheEntry(table, value);
+                      let row;
+                      if (entry?.row) {
+                        row = entry.row;
+                      } else {
+                        if (isDatabaseEmpty)
+                          row = null;
+                        else
+                          row = await find(table, value);
+                      }
+                      if (row === null) {
+                        rows.push(
+                          setCacheEntry(table, value, 0 /* INSERT */)
+                        );
+                      } else {
+                        rows.push(null);
+                      }
+                    }
+                    return rows;
+                  } else {
+                    const entry = getCacheEntry(table, values);
+                    let row;
+                    if (entry?.row) {
+                      row = entry.row;
+                    } else {
+                      if (isDatabaseEmpty)
+                        row = null;
+                      else
+                        row = await find(table, values);
+                    }
+                    if (row === null) {
+                      return setCacheEntry(table, values, 0 /* INSERT */);
+                    }
+                    return null;
+                  }
+                }
+              )
+            ),
+            onConflictDoUpdate: (valuesU) => queue.add(
+              () => database.wrap(
+                {
+                  method: `${getTableName2(table) ?? "unknown"}.insert()`
+                },
+                async () => {
+                  checkOnchainTable(table, "insert");
+                  if (Array.isArray(values)) {
+                    const rows = [];
+                    for (const value of values) {
+                      const entry = getCacheEntry(table, value);
+                      deleteCacheEntry(table, value);
+                      let row;
+                      if (entry?.row) {
+                        row = entry.row;
+                      } else {
+                        if (isDatabaseEmpty)
+                          row = null;
+                        else
+                          row = await find(table, value);
+                      }
+                      if (row === null) {
+                        rows.push(
+                          setCacheEntry(table, value, 0 /* INSERT */)
+                        );
+                      } else {
+                        if (typeof valuesU === "function") {
+                          rows.push(
+                            setCacheEntry(
+                              table,
+                              valuesU(row),
+                              entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
+                              row
+                            )
+                          );
+                        } else {
+                          rows.push(
+                            setCacheEntry(
+                              table,
+                              valuesU,
+                              entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
+                              row
+                            )
+                          );
+                        }
+                      }
+                    }
+                    return rows;
+                  } else {
+                    const entry = getCacheEntry(table, values);
+                    deleteCacheEntry(table, values);
+                    let row;
+                    if (entry?.row) {
+                      row = entry.row;
+                    } else {
+                      if (isDatabaseEmpty)
+                        row = null;
+                      else
+                        row = await find(table, values);
+                    }
+                    if (row === null) {
+                      return setCacheEntry(table, values, 0 /* INSERT */);
+                    } else {
+                      if (typeof valuesU === "function") {
+                        return setCacheEntry(
+                          table,
+                          valuesU(row),
+                          entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
+                          row
+                        );
+                      } else {
+                        return setCacheEntry(
+                          table,
+                          valuesU,
+                          entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
+                          row
+                        );
+                      }
+                    }
+                  }
+                }
+              )
+            ),
+            // biome-ignore lint/suspicious/noThenProperty: <explanation>
+            then: (onFulfilled, onRejected) => queue.add(
+              () => database.wrap(
+                {
+                  method: `${getTableName2(table) ?? "unknown"}.insert()`
+                },
+                async () => {
+                  checkOnchainTable(table, "insert");
+                  if (Array.isArray(values)) {
+                    const rows = [];
+                    for (const value of values) {
+                      if (getCacheEntry(table, value)?.row) {
+                        const error = new UniqueConstraintError(
+                          `Unique constraint failed for '${getTableName2(table)}'.`
+                        );
+                        error.meta.push(
+                          `db.insert arguments:
+${prettyPrint(value)}`
+                        );
+                        throw error;
+                      } else if (isDatabaseEmpty === false) {
+                        const findResult = await find(table, value);
+                        if (findResult) {
+                          const error = new UniqueConstraintError(
+                            `Unique constraint failed for '${getTableName2(table)}'.`
+                          );
+                          error.meta.push(
+                            `db.insert arguments:
+${prettyPrint(value)}`
+                          );
+                          throw error;
+                        }
+                      }
+                      rows.push(
+                        setCacheEntry(table, value, 0 /* INSERT */)
+                      );
+                    }
+                    return rows;
+                  } else {
+                    if (getCacheEntry(table, values)?.row) {
+                      const error = new UniqueConstraintError(
+                        `Unique constraint failed for '${getTableName2(table)}'.`
+                      );
+                      error.meta.push(
+                        `db.insert arguments:
+${prettyPrint(values)}`
+                      );
+                      throw error;
+                    } else if (isDatabaseEmpty === false) {
+                      const findResult = await find(table, values);
+                      if (findResult) {
+                        const error = new UniqueConstraintError(
+                          `Unique constraint failed for '${getTableName2(table)}'.`
+                        );
+                        error.meta.push(
+                          `db.insert arguments:
+${prettyPrint(values)}`
+                        );
+                        throw error;
+                      }
+                    }
+                    return setCacheEntry(table, values, 0 /* INSERT */);
+                  }
+                }
+              )
+            ).then(onFulfilled, onRejected),
+            catch: (onRejected) => inner.then(void 0, onRejected),
+            finally: (onFinally) => inner.then(
+              (value) => {
+                onFinally?.();
+                return value;
+              },
+              (reason) => {
+                onFinally?.();
+                throw reason;
+              }
+            )
+            // @ts-ignore
+          };
+          return inner;
+        }
+      };
+    },
+    // @ts-ignore
+    update(table, key) {
+      return {
+        set: (values) => queue.add(
+          () => database.wrap(
+            { method: `${getTableName2(table) ?? "unknown"}.update()` },
+            async () => {
+              checkOnchainTable(table, "update");
+              const entry = getCacheEntry(table, key);
+              deleteCacheEntry(table, key);
+              let row;
+              if (entry?.row) {
+                row = entry.row;
+              } else {
+                if (isDatabaseEmpty) {
+                  const error = new RecordNotFoundError(
+                    `No existing record found in table '${getTableName2(table)}'`
+                  );
+                  error.meta.push(
+                    `db.update arguments:
+${prettyPrint(key)}`
+                  );
+                  throw error;
+                }
+                const findResult = await find(table, key);
+                if (findResult) {
+                  row = findResult;
+                } else {
+                  const error = new RecordNotFoundError(
+                    `No existing record found in table '${getTableName2(table)}'`
+                  );
+                  error.meta.push(
+                    `db.update arguments:
+${prettyPrint(key)}`
+                  );
+                  throw error;
+                }
+              }
+              if (typeof values === "function") {
+                return setCacheEntry(
+                  table,
+                  values(row),
+                  entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
+                  row
+                );
+              } else {
+                return setCacheEntry(
+                  table,
+                  values,
+                  entry?.type === 0 /* INSERT */ ? 0 /* INSERT */ : 1 /* UPDATE */,
+                  row
+                );
+              }
+            }
+          )
+        )
+      };
+    },
+    // @ts-ignore
+    delete: (table, key) => queue.add(
+      () => database.wrap(
+        { method: `${getTableName2(table) ?? "unknown"}.delete()` },
+        async () => {
+          checkOnchainTable(table, "delete");
+          const entry = getCacheEntry(table, key);
+          deleteCacheEntry(table, key);
+          if (entry?.row) {
+            if (entry.type === 0 /* INSERT */) {
+              return true;
+            }
+            await database.qb.drizzle.delete(table).where(getWhereCondition(table, key));
+            return true;
+          } else {
+            if (isDatabaseEmpty) {
+              return false;
+            }
+            const deleteResult = await database.qb.drizzle.delete(table).where(getWhereCondition(table, key)).returning();
+            return deleteResult.length > 0;
+          }
+        }
+      )
+    ),
+    // @ts-ignore
+    sql: drizzle(
+      async (_sql, params, method, typings) => {
+        await database.createTriggers();
+        await indexingStore.flush();
+        await database.removeTriggers();
+        isDatabaseEmpty = false;
+        const query = { sql: _sql, params, typings };
+        const res = await database.wrap({ method: "sql" }, async () => {
+          try {
+            return await database.qb.drizzle._.session.prepareQuery(query, void 0, void 0, method === "all").execute();
+          } catch (e) {
+            throw parseSqlError(e);
+          }
+        });
+        return { rows: res.rows.map((row) => Object.values(row)) };
+      },
+      { schema, casing: "snake_case" }
+    ),
+    async flush() {
+      await queue.add(async () => {
+        let cacheSize = 0;
+        for (const c of cache.values())
+          cacheSize += c.size;
+        const flushIndex = totalCacheOps - cacheSize * (1 - common.options.indexingCacheFlushRatio);
+        const shouldDelete = cacheBytes > maxBytes;
+        if (shouldDelete)
+          isDatabaseEmpty = false;
+        const promises = [];
+        for (const [table, tableCache] of cache) {
+          const batchSize = Math.round(
+            common.options.databaseMaxQueryParameters / Object.keys(getTableColumns2(table)).length
+          );
+          const insertValues = [];
+          const updateValues = [];
+          for (const [key, entry] of tableCache) {
+            if (entry.type === 0 /* INSERT */) {
+              insertValues.push(entry.row);
+            }
+            if (entry.type === 1 /* UPDATE */) {
+              updateValues.push(entry.row);
+            }
+            if (shouldDelete && entry.operationIndex < flushIndex) {
+              tableCache.delete(key);
+              cacheBytes -= entry.bytes;
+            }
+            entry.type = 2 /* FIND */;
+          }
+          if (insertValues.length > 0) {
+            common.logger.debug({
+              service: "indexing",
+              msg: `Inserting ${insertValues.length} cached '${getTableName2(table)}' rows into the database`
+            });
+            while (insertValues.length > 0) {
+              const values = insertValues.splice(0, batchSize);
+              promises.push(
+                database.wrap(
+                  { method: `${getTableName2(table)}.flush()` },
+                  async () => {
+                    await database.qb.drizzle.insert(table).values(values).catch((_error) => {
+                      const error = _error;
+                      common.logger.error({
+                        service: "indexing",
+                        msg: "Internal error occurred while flushing cache. Please report this error here: https://github.com/ponder-sh/ponder/issues"
+                      });
+                      throw new FlushError(error.message);
+                    });
+                  }
+                )
+              );
+            }
+          }
+          if (updateValues.length > 0) {
+            common.logger.debug({
+              service: "indexing",
+              msg: `Updating ${updateValues.length} cached '${getTableName2(table)}' rows in the database`
+            });
+            const primaryKeys = primaryKeysCache.get(table);
+            const set = {};
+            for (const [columnName, column] of Object.entries(
+              getTableColumns2(table)
+            )) {
+              set[columnName] = sql.raw(
+                `excluded."${getColumnCasing(column, "snake_case")}"`
+              );
+            }
+            while (updateValues.length > 0) {
+              const values = updateValues.splice(0, batchSize);
+              promises.push(
+                database.wrap(
+                  {
+                    method: `${getTableName2(table)}.flush()`
+                  },
+                  async () => {
+                    await database.qb.drizzle.insert(table).values(values).onConflictDoUpdate({
+                      // @ts-ignore
+                      target: primaryKeys.map(({ js }) => table[js]),
+                      set
+                    }).catch((_error) => {
+                      const error = _error;
+                      common.logger.error({
+                        service: "indexing",
+                        msg: "Internal error occurred while flushing cache. Please report this error here: https://github.com/ponder-sh/ponder/issues"
+                      });
+                      throw new FlushError(error.message);
+                    });
+                  }
+                )
+              );
+            }
+          }
+        }
+        await Promise.all(promises);
+      });
+    },
+    isCacheFull() {
+      return cacheBytes > maxBytes;
+    }
+  };
+  return indexingStore;
+};
+
+// src/indexing-store/realtime.ts
+import {
+  and as and2,
+  eq as eq2,
+  getTableName as getTableName3
+} from "drizzle-orm";
+import { getTableConfig as getTableConfig4 } from "drizzle-orm/pg-core";
+import { drizzle as drizzle2 } from "drizzle-orm/pg-proxy";
+var checkOnchainTable2 = (table, method) => {
+  if (table === void 0)
+    throw new UndefinedTableError(
+      `Table object passed to db.${method}() is undefined`
+    );
+  if (onchain in table)
+    return;
+  throw new InvalidStoreMethodError(
+    method === "find" ? `db.find() can only be used with onchain tables, and '${getTableConfig4(table).name}' is an offchain table.` : `Indexing functions can only write to onchain tables, and '${getTableConfig4(table).name}' is an offchain table.`
+  );
+};
+var createRealtimeIndexingStore = ({
+  schemaBuild: { schema },
+  database
+}) => {
+  const queue = createQueue({
+    browser: false,
+    initialStart: true,
+    concurrency: 1,
+    worker: (fn) => {
+      return fn();
+    }
+  });
+  const primaryKeysCache = /* @__PURE__ */ new Map();
+  for (const tableName of getTableNames(schema)) {
+    primaryKeysCache.set(
+      schema[tableName.js],
+      getPrimaryKeyColumns(schema[tableName.js])
+    );
+  }
+  const getCacheKey = (table, row) => {
+    const primaryKeys = primaryKeysCache.get(table);
+    return primaryKeys.map((pk) => normalizeColumn(table[pk.js], row[pk.js])).join("_");
+  };
+  const getWhereCondition = (table, key) => {
+    primaryKeysCache.get(table);
+    const conditions = [];
+    for (const { js } of primaryKeysCache.get(table)) {
+      conditions.push(eq2(table[js], key[js]));
+    }
+    return and2(...conditions);
+  };
+  const find = (table, key) => {
+    return database.qb.drizzle.select().from(table).where(getWhereCondition(table, key)).then((res) => res.length === 0 ? null : res[0]);
+  };
+  const indexingStore = {
+    // @ts-ignore
+    find: (table, key) => queue.add(
+      () => database.wrap(
+        { method: `${getTableName3(table) ?? "unknown"}.find()` },
+        async () => {
+          checkOnchainTable2(table, "find");
+          return find(table, key);
+        }
+      )
+    ),
+    // @ts-ignore
+    insert(table) {
+      return {
+        values: (values) => {
+          const inner = {
+            onConflictDoNothing: () => queue.add(
+              () => database.wrap(
+                {
+                  method: `${getTableName3(table) ?? "unknown"}.insert()`
+                },
+                async () => {
+                  checkOnchainTable2(table, "insert");
+                  const parseResult = (result) => {
+                    if (Array.isArray(values) === false) {
+                      return result.length === 1 ? result[0] : null;
+                    }
+                    const rows = [];
+                    let resultIndex = 0;
+                    for (let i = 0; i < values.length; i++) {
+                      if (getCacheKey(table, values[i]) === getCacheKey(table, result[resultIndex])) {
+                        rows.push(result[resultIndex++]);
+                      } else {
+                        rows.push(null);
+                      }
+                    }
+                    return rows;
+                  };
+                  try {
+                    return await database.qb.drizzle.insert(table).values(values).onConflictDoNothing().returning().then(parseResult);
+                  } catch (e) {
+                    throw parseSqlError(e);
+                  }
+                }
+              )
+            ),
+            onConflictDoUpdate: (valuesU) => queue.add(
+              () => database.wrap(
+                {
+                  method: `${getTableName3(table) ?? "unknown"}.insert()`
+                },
+                async () => {
+                  checkOnchainTable2(table, "insert");
+                  if (typeof valuesU === "object") {
+                    try {
+                      return await database.qb.drizzle.insert(table).values(values).onConflictDoUpdate({
+                        target: primaryKeysCache.get(table).map(({ js }) => table[js]),
+                        set: valuesU
+                      }).returning().then(
+                        (res) => Array.isArray(values) ? res : res[0]
+                      );
+                    } catch (e) {
+                      throw parseSqlError(e);
+                    }
+                  }
+                  if (Array.isArray(values)) {
+                    const rows = [];
+                    for (const value of values) {
+                      const row = await find(table, value);
+                      if (row === null) {
+                        try {
+                          rows.push(
+                            await database.qb.drizzle.insert(table).values(value).returning().then((res) => res[0])
+                          );
+                        } catch (e) {
+                          throw parseSqlError(e);
+                        }
+                      } else {
+                        try {
+                          rows.push(
+                            await database.qb.drizzle.update(table).set(valuesU(row)).where(getWhereCondition(table, value)).returning().then((res) => res[0])
+                          );
+                        } catch (e) {
+                          throw parseSqlError(e);
+                        }
+                      }
+                    }
+                    return rows;
+                  } else {
+                    const row = await find(table, values);
+                    if (row === null) {
+                      try {
+                        return await database.qb.drizzle.insert(table).values(values).returning().then((res) => res[0]);
+                      } catch (e) {
+                        throw parseSqlError(e);
+                      }
+                    } else {
+                      try {
+                        return await database.qb.drizzle.update(table).set(valuesU(row)).where(getWhereCondition(table, values)).returning().then((res) => res[0]);
+                      } catch (e) {
+                        throw parseSqlError(e);
+                      }
+                    }
+                  }
+                }
+              )
+            ),
+            // biome-ignore lint/suspicious/noThenProperty: <explanation>
+            then: (onFulfilled, onRejected) => queue.add(
+              () => database.wrap(
+                {
+                  method: `${getTableName3(table) ?? "unknown"}.insert()`
+                },
+                async () => {
+                  checkOnchainTable2(table, "insert");
+                  try {
+                    return await database.qb.drizzle.insert(table).values(values).returning().then(
+                      (res) => Array.isArray(values) ? res : res[0]
+                    );
+                  } catch (e) {
+                    throw parseSqlError(e);
+                  }
+                }
+              )
+            ).then(onFulfilled, onRejected),
+            catch: (onRejected) => inner.then(void 0, onRejected),
+            finally: (onFinally) => inner.then(
+              (value) => {
+                onFinally?.();
+                return value;
+              },
+              (reason) => {
+                onFinally?.();
+                throw reason;
+              }
+            )
+            // @ts-ignore
+          };
+          return inner;
+        }
+      };
+    },
+    // @ts-ignore
+    update(table, key) {
+      return {
+        set: (values) => queue.add(
+          () => database.wrap(
+            { method: `${getTableName3(table) ?? "unknown"}.update()` },
+            async () => {
+              checkOnchainTable2(table, "update");
+              if (typeof values === "function") {
+                const row = await find(table, key);
+                if (row === null) {
+                  const error = new RecordNotFoundError(
+                    `No existing record found in table '${getTableName3(table)}'`
+                  );
+                  error.meta.push(
+                    `db.update arguments:
+${prettyPrint(key)}`
+                  );
+                  throw error;
+                }
+                try {
+                  return await database.qb.drizzle.update(table).set(values(row)).where(getWhereCondition(table, key)).returning().then((res) => res[0]);
+                } catch (e) {
+                  throw parseSqlError(e);
+                }
+              } else {
+                try {
+                  return await database.qb.drizzle.update(table).set(values).where(getWhereCondition(table, key)).returning().then((res) => res[0]);
+                } catch (e) {
+                  throw parseSqlError(e);
+                }
+              }
+            }
+          )
+        )
+      };
+    },
+    // @ts-ignore
+    delete: (table, key) => queue.add(
+      () => database.wrap(
+        { method: `${getTableName3(table) ?? "unknown"}.delete()` },
+        async () => {
+          checkOnchainTable2(table, "delete");
+          const deleted = await database.qb.drizzle.delete(table).where(getWhereCondition(table, key)).returning();
+          return deleted.length > 0;
+        }
+      )
+    ),
+    // @ts-ignore
+    sql: drizzle2(
+      (_sql, params, method, typings) => (
+        // @ts-ignore
+        queue.add(async () => {
+          const query = { sql: _sql, params, typings };
+          const res = await database.wrap({ method: "sql" }, async () => {
+            try {
+              return await database.qb.drizzle._.session.prepareQuery(query, void 0, void 0, method === "all").execute();
+            } catch (e) {
+              throw parseSqlError(e);
+            }
+          });
+          return { rows: res.rows.map((row) => Object.values(row)) };
+        })
+      ),
+      { schema, casing: "snake_case" }
+    )
+  };
+  return indexingStore;
+};
+
+export {
+  getSql,
+  getColumnCasing,
+  getTableNames,
+  getPrimaryKeyColumns,
+  BuildError,
+  NonRetryableError,
+  ShutdownError,
+  prettyPrint,
+  createHistoricalIndexingStore,
+  createRealtimeIndexingStore
+};
+//# sourceMappingURL=chunk-6AOFLZJ4.js.map