@apibara/indexer 2.0.0-beta.6 → 2.0.0-beta.7

package/dist/sinks/drizzle/index.d.mts

@@ -0,0 +1,111 @@
+import { Cursor } from '@apibara/protocol';
+import { TablesRelationalConfig, ExtractTablesWithRelations, SQL } from 'drizzle-orm';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import { PgTable, PgQueryResultHKT, PgTransaction, PgUpdateBase, PgInsertValue, PgUpdateSetSource, PgSelectBuilder, SelectedFields, TableConfig, PgTableWithColumns, PgDatabase, AnyPgTable, PgTableFn } from 'drizzle-orm/pg-core';
+import { S as Sink, a as SinkCursorParams } from '../../shared/indexer.b9c8f0d8.mjs';
+import { Range } from 'postgres-range';
+
+declare class DrizzleSinkDelete<TTable extends PgTable, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private table;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, table: TTable, endCursor?: Cursor | undefined);
+    where(where: SQL): Omit<PgUpdateBase<TTable, TQueryResult, undefined, false, "where">, "where">;
+}
+
+declare class DrizzleSinkInsert<TTable extends PgTable, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private table;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, table: TTable, endCursor?: Cursor | undefined);
+    values(values: PgInsertValue<TTable> | PgInsertValue<TTable>[]): drizzle_orm_pg_core.PgInsertBase<TTable, TQueryResult, undefined, false, never>;
+}
+
+declare class DrizzleSinkUpdate<TTable extends PgTable, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private table;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, table: TTable, endCursor?: Cursor | undefined);
+    set(values: PgUpdateSetSource<TTable>): PgUpdateBase<TTable, TQueryResult>;
+}
+
+declare class DrizzleSinkTransaction<TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, endCursor?: Cursor | undefined);
+    insert<TTable extends PgTable>(table: TTable): DrizzleSinkInsert<TTable, TQueryResult, TFullSchema, TSchema>;
+    update<TTable extends PgTable>(table: TTable): DrizzleSinkUpdate<TTable, TQueryResult, TFullSchema, TSchema>;
+    delete<TTable extends PgTable>(table: TTable): DrizzleSinkDelete<TTable, TQueryResult, TFullSchema, TSchema>;
+    select(): PgSelectBuilder<undefined>;
+    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+}
+
+type DrizzleSinkTables<TTableConfig extends Record<string, TableConfig>> = {
+    [K in keyof TTableConfig]: PgTableWithColumns<TTableConfig[K]>;
+};
+type DrizzleSinkOptions<TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> = {
+    /**
+     * Database instance of drizzle-orm
+     */
+    database: PgDatabase<TQueryResult, TFullSchema, TSchema>;
+    tables: AnyPgTable[];
+};
+/**
+ * A sink that writes data to a PostgreSQL database using Drizzle ORM.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = drizzle({
+ *   database: db,
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { transaction } = useSink(context);
+ *  const db = transaction(endCursor);
+ *
+ *  db.insert(users).values([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class DrizzleSink<TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> extends Sink {
+    private _db;
+    private _tables;
+    constructor(options: DrizzleSinkOptions<TQueryResult, TFullSchema, TSchema>);
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: {
+        db: DrizzleSinkTransaction<TQueryResult, TFullSchema, TSchema>;
+    }) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare const drizzle: <TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>(args: DrizzleSinkOptions<TQueryResult, TFullSchema, TSchema>) => DrizzleSink<TQueryResult, TFullSchema, TSchema>;
+
+type Comparable = string | number;
+type RangeBound<T extends Comparable> = T | {
+    value: T;
+    inclusive: boolean;
+};
+declare class Int8Range {
+    readonly range: Range<number>;
+    constructor(range: Range<number>);
+    get start(): RangeBound<number> | null;
+    get end(): RangeBound<number> | null;
+}
+declare const int8range: <TName extends string>(dbName: TName, fieldConfig?: unknown) => drizzle_orm_pg_core.PgCustomColumnBuilder<{
+    name: TName;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: Int8Range;
+    driverParam: unknown;
+    enumValues: undefined;
+    generated: undefined;
+}>;
+
+declare const pgTable: PgTableFn;
+declare const getDrizzleCursor: (cursor_range: [bigint | undefined, bigint | undefined] | bigint | undefined) => Int8Range;
+
+export { DrizzleSink, DrizzleSinkDelete, type DrizzleSinkOptions, type DrizzleSinkTables, DrizzleSinkTransaction, DrizzleSinkUpdate, Int8Range, drizzle, getDrizzleCursor, int8range, pgTable };

package/dist/sinks/drizzle/index.d.ts

@@ -0,0 +1,111 @@
+import { Cursor } from '@apibara/protocol';
+import { TablesRelationalConfig, ExtractTablesWithRelations, SQL } from 'drizzle-orm';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import { PgTable, PgQueryResultHKT, PgTransaction, PgUpdateBase, PgInsertValue, PgUpdateSetSource, PgSelectBuilder, SelectedFields, TableConfig, PgTableWithColumns, PgDatabase, AnyPgTable, PgTableFn } from 'drizzle-orm/pg-core';
+import { S as Sink, a as SinkCursorParams } from '../../shared/indexer.b9c8f0d8.js';
+import { Range } from 'postgres-range';
+
+declare class DrizzleSinkDelete<TTable extends PgTable, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private table;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, table: TTable, endCursor?: Cursor | undefined);
+    where(where: SQL): Omit<PgUpdateBase<TTable, TQueryResult, undefined, false, "where">, "where">;
+}
+
+declare class DrizzleSinkInsert<TTable extends PgTable, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private table;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, table: TTable, endCursor?: Cursor | undefined);
+    values(values: PgInsertValue<TTable> | PgInsertValue<TTable>[]): drizzle_orm_pg_core.PgInsertBase<TTable, TQueryResult, undefined, false, never>;
+}
+
+declare class DrizzleSinkUpdate<TTable extends PgTable, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private table;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, table: TTable, endCursor?: Cursor | undefined);
+    set(values: PgUpdateSetSource<TTable>): PgUpdateBase<TTable, TQueryResult>;
+}
+
+declare class DrizzleSinkTransaction<TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    private db;
+    private endCursor?;
+    constructor(db: PgTransaction<TQueryResult, TFullSchema, TSchema>, endCursor?: Cursor | undefined);
+    insert<TTable extends PgTable>(table: TTable): DrizzleSinkInsert<TTable, TQueryResult, TFullSchema, TSchema>;
+    update<TTable extends PgTable>(table: TTable): DrizzleSinkUpdate<TTable, TQueryResult, TFullSchema, TSchema>;
+    delete<TTable extends PgTable>(table: TTable): DrizzleSinkDelete<TTable, TQueryResult, TFullSchema, TSchema>;
+    select(): PgSelectBuilder<undefined>;
+    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+}
+
+type DrizzleSinkTables<TTableConfig extends Record<string, TableConfig>> = {
+    [K in keyof TTableConfig]: PgTableWithColumns<TTableConfig[K]>;
+};
+type DrizzleSinkOptions<TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> = {
+    /**
+     * Database instance of drizzle-orm
+     */
+    database: PgDatabase<TQueryResult, TFullSchema, TSchema>;
+    tables: AnyPgTable[];
+};
+/**
+ * A sink that writes data to a PostgreSQL database using Drizzle ORM.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = drizzle({
+ *   database: db,
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { transaction } = useSink(context);
+ *  const db = transaction(endCursor);
+ *
+ *  db.insert(users).values([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class DrizzleSink<TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> extends Sink {
+    private _db;
+    private _tables;
+    constructor(options: DrizzleSinkOptions<TQueryResult, TFullSchema, TSchema>);
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: {
+        db: DrizzleSinkTransaction<TQueryResult, TFullSchema, TSchema>;
+    }) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare const drizzle: <TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>(args: DrizzleSinkOptions<TQueryResult, TFullSchema, TSchema>) => DrizzleSink<TQueryResult, TFullSchema, TSchema>;
+
+type Comparable = string | number;
+type RangeBound<T extends Comparable> = T | {
+    value: T;
+    inclusive: boolean;
+};
+declare class Int8Range {
+    readonly range: Range<number>;
+    constructor(range: Range<number>);
+    get start(): RangeBound<number> | null;
+    get end(): RangeBound<number> | null;
+}
+declare const int8range: <TName extends string>(dbName: TName, fieldConfig?: unknown) => drizzle_orm_pg_core.PgCustomColumnBuilder<{
+    name: TName;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: Int8Range;
+    driverParam: unknown;
+    enumValues: undefined;
+    generated: undefined;
+}>;
+
+declare const pgTable: PgTableFn;
+declare const getDrizzleCursor: (cursor_range: [bigint | undefined, bigint | undefined] | bigint | undefined) => Int8Range;
+
+export { DrizzleSink, DrizzleSinkDelete, type DrizzleSinkOptions, type DrizzleSinkTables, DrizzleSinkTransaction, DrizzleSinkUpdate, Int8Range, drizzle, getDrizzleCursor, int8range, pgTable };

package/dist/sinks/drizzle/index.mjs

@@ -0,0 +1,196 @@
+import { sql, gt } from 'drizzle-orm';
+import { S as Sink } from '../../shared/indexer.93d6b2eb.mjs';
+import { customType, pgTable as pgTable$1 } from 'drizzle-orm/pg-core';
+import range, { parse, serialize } from 'postgres-range';
+import 'consola';
+
+class DrizzleSinkDelete {
+  constructor(db, table, endCursor) {
+    this.db = db;
+    this.table = table;
+    this.endCursor = endCursor;
+  }
+  //@ts-ignore
+  where(where) {
+    return this.db.update(this.table).set({
+      // @ts-ignore
+      _cursor: sql`int8range(lower(_cursor), ${Number(this.endCursor?.orderKey)}, '[)')`
+    }).where(where);
+  }
+}
+
+class Int8Range {
+  constructor(range) {
+    this.range = range;
+  }
+  get start() {
+    return this.range.lower != null ? {
+      value: this.range.lower,
+      inclusive: this.range.isLowerBoundClosed()
+    } : null;
+  }
+  get end() {
+    return this.range.upper != null ? {
+      value: this.range.upper,
+      inclusive: this.range.isUpperBoundClosed()
+    } : null;
+  }
+}
+const int8range = customType({
+  dataType: () => "int8range",
+  fromDriver: (value) => {
+    if (typeof value !== "string") {
+      throw new Error("Expected string");
+    }
+    const parsed = parse(value, (val) => Number.parseInt(val, 10));
+    return new Int8Range(parsed);
+  },
+  toDriver: (value) => serialize(value.range)
+});
+
+const pgTable = (name, columns, extraConfig) => {
+  return pgTable$1(
+    name,
+    {
+      ...columns,
+      _cursor: int8range("_cursor").notNull()
+    },
+    extraConfig
+  );
+};
+const getDrizzleCursor = (cursor_range) => {
+  const isArray = Array.isArray(cursor_range);
+  const [lower, upper] = isArray ? cursor_range : [cursor_range, void 0];
+  let isNoUpperBound = false;
+  if (!lower) {
+    throw new Error("Lower bound cursor is required");
+  }
+  if (!upper) {
+    isNoUpperBound = true;
+  }
+  return new Int8Range(
+    new range.Range(
+      Number(lower),
+      Number(upper),
+      range.RANGE_LB_INC | (isNoUpperBound ? range.RANGE_UB_INF : 0)
+    )
+  );
+};
+
+class DrizzleSinkInsert {
+  constructor(db, table, endCursor) {
+    this.db = db;
+    this.table = table;
+    this.endCursor = endCursor;
+  }
+  values(values) {
+    const originalInsert = this.db.insert(this.table);
+    const cursoredValues = (Array.isArray(values) ? values : [values]).map(
+      (v) => {
+        return {
+          ...v,
+          _cursor: getDrizzleCursor(this.endCursor?.orderKey)
+        };
+      }
+    );
+    return originalInsert.values(cursoredValues);
+  }
+}
+
+class DrizzleSinkSelect {
+  constructor(db, fields, endCursor) {
+    this.db = db;
+    this.fields = fields;
+    this.endCursor = endCursor;
+  }
+  from(source) {
+    if (this.fields) {
+      const originalFrom = this.db.select(this.fields).from(source);
+      return {
+        ...originalFrom,
+        where: (where) => {
+          const combinedWhere = sql`${where ? sql`${where} AND ` : sql``}upper_inf(_cursor)`;
+          return originalFrom.where(combinedWhere);
+        }
+      };
+    }
+    return this.db.select().from(source).where(sql`upper_inf(_cursor)`);
+  }
+}
+
+class DrizzleSinkUpdate {
+  constructor(db, table, endCursor) {
+    this.db = db;
+    this.table = table;
+    this.endCursor = endCursor;
+  }
+  set(values) {
+    const originalUpdate = this.db.update(this.table);
+    const originalSet = originalUpdate.set(values);
+    return {
+      ...originalSet,
+      where: async (where) => {
+        await this.db.update(this.table).set({
+          _cursor: sql`int8range(lower(_cursor), ${Number(this.endCursor?.orderKey)}, '[)')`
+        }).where(sql`${where ? sql`${where} AND ` : sql``}upper_inf(_cursor)`).execute();
+        return originalSet.where(where);
+      }
+    };
+  }
+}
+
+class DrizzleSinkTransaction {
+  constructor(db, endCursor) {
+    this.db = db;
+    this.endCursor = endCursor;
+  }
+  insert(table) {
+    return new DrizzleSinkInsert(this.db, table, this.endCursor);
+  }
+  update(table) {
+    return new DrizzleSinkUpdate(this.db, table, this.endCursor);
+  }
+  delete(table) {
+    return new DrizzleSinkDelete(this.db, table, this.endCursor);
+  }
+  select(fields) {
+    return new DrizzleSinkSelect(this.db, fields, this.endCursor);
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class DrizzleSink extends Sink {
+  constructor(options) {
+    super();
+    __publicField(this, "_db");
+    __publicField(this, "_tables");
+    const { database, tables } = options;
+    this._db = database;
+    this._tables = tables;
+  }
+  async transaction({ cursor, endCursor, finality }, cb) {
+    await this._db.transaction(async (db) => {
+      await cb({ db: new DrizzleSinkTransaction(db, endCursor) });
+    });
+  }
+  async invalidate(cursor) {
+    await this._db.transaction(async (db) => {
+      for (const table of this._tables) {
+        await db.delete(table).where(gt(sql`lower(_cursor)`, sql`${Number(cursor?.orderKey)}`)).returning();
+        await db.update(table).set({
+          _cursor: sql`int8range(lower(_cursor), NULL, '[)')`
+        }).where(gt(sql`upper(_cursor)`, sql`${Number(cursor?.orderKey)}`));
+      }
+    });
+  }
+}
+const drizzle = (args) => {
+  return new DrizzleSink(args);
+};
+
+export { DrizzleSink, DrizzleSinkDelete, DrizzleSinkTransaction, DrizzleSinkUpdate, Int8Range, drizzle, getDrizzleCursor, int8range, pgTable };

package/dist/sinks/sqlite.d.cts

@@ -1,6 +1,6 @@
 import { Cursor } from '@apibara/protocol';
 import { Database } from 'better-sqlite3';
-import { b as Sink, a as SinkCursorParams, S as SinkData } from '../shared/indexer.d227f25c.cjs';
+import { S as Sink, a as SinkCursorParams, b as SinkData } from '../shared/indexer.b9c8f0d8.cjs';
 
 type SqliteSinkOptions = {
     /**

package/dist/sinks/sqlite.d.mts

@@ -1,6 +1,6 @@
 import { Cursor } from '@apibara/protocol';
 import { Database } from 'better-sqlite3';
-import { b as Sink, a as SinkCursorParams, S as SinkData } from '../shared/indexer.d227f25c.mjs';
+import { S as Sink, a as SinkCursorParams, b as SinkData } from '../shared/indexer.b9c8f0d8.mjs';
 
 type SqliteSinkOptions = {
     /**

package/dist/sinks/sqlite.d.ts

@@ -1,6 +1,6 @@
 import { Cursor } from '@apibara/protocol';
 import { Database } from 'better-sqlite3';
-import { b as Sink, a as SinkCursorParams, S as SinkData } from '../shared/indexer.d227f25c.js';
+import { S as Sink, a as SinkCursorParams, b as SinkData } from '../shared/indexer.b9c8f0d8.js';
 
 type SqliteSinkOptions = {
     /**

package/dist/testing/index.cjs

@@ -1,19 +1,20 @@
 'use strict';
 
 const vitest = require('vitest');
-const replay = require('../shared/indexer.99ec3128.cjs');
-require('node:fs/promises');
-require('node:path');
-require('consola');
-require('klona/full');
-require('node:assert');
-require('node:fs');
-require('@apibara/protocol/testing');
-require('hookable');
+const helper = require('../shared/indexer.318d3617.cjs');
+const vcr_index = require('../shared/indexer.541d43eb.cjs');
 require('node:async_hooks');
 require('unctx');
 require('@opentelemetry/api');
+require('node:fs');
+require('node:path');
+require('node:fs/promises');
+require('klona/full');
+require('consola');
+require('hookable');
+require('node:assert');
 require('../shared/indexer.a8b7ab1f.cjs');
+require('@apibara/protocol/testing');
 
 const test = vitest.test.extend({
   vcr: {
@@ -35,11 +36,11 @@ async function withClient(cassetteName, range, callback) {
   };
   const context = {
     async run(indexer) {
-      const client = replay.loadCassette(vcrConfig, cassetteName);
-      if (!replay.isCassetteAvailable(vcrConfig, cassetteName)) {
-        await replay.record(vcrConfig, client, indexer, cassetteOptions);
+      const client = vcr_index.loadCassette(vcrConfig, cassetteName);
+      if (!helper.isCassetteAvailable(vcrConfig, cassetteName)) {
+        await vcr_index.record(vcrConfig, client, indexer, cassetteOptions);
       }
-      return await replay.replay(vcrConfig, indexer, cassetteName);
+      return await vcr_index.replay(vcrConfig, indexer, cassetteName);
     }
   };
   await callback(context);
@@ -57,7 +58,7 @@ function generateMockMessages(count = 10) {
   }));
 }
 
-exports.VcrSink = replay.VcrSink;
-exports.vcr = replay.vcr;
+exports.VcrSink = vcr_index.VcrSink;
+exports.vcr = vcr_index.vcr;
 exports.generateMockMessages = generateMockMessages;
 exports.test = test;

package/dist/testing/index.d.cts

@@ -1,7 +1,8 @@
 import * as vitest from 'vitest';
-import { I as Indexer, j as VcrReplayResult } from '../shared/indexer.ff960804.cjs';
+import { f as Indexer } from '../shared/indexer.c7ed6b83.cjs';
+import { a as VcrReplayResult } from '../shared/indexer.500fd281.cjs';
 import { Cursor } from '@apibara/protocol';
-import { b as Sink, S as SinkData, a as SinkCursorParams } from '../shared/indexer.d227f25c.cjs';
+import { S as Sink, b as SinkData, a as SinkCursorParams } from '../shared/indexer.b9c8f0d8.cjs';
 import { MockStreamResponse } from '@apibara/protocol/testing';
 import 'hookable';
 

package/dist/testing/index.d.mts

@@ -1,7 +1,8 @@
 import * as vitest from 'vitest';
-import { I as Indexer, j as VcrReplayResult } from '../shared/indexer.9aa22867.mjs';
+import { f as Indexer } from '../shared/indexer.e8bd138d.mjs';
+import { a as VcrReplayResult } from '../shared/indexer.e1856641.mjs';
 import { Cursor } from '@apibara/protocol';
-import { b as Sink, S as SinkData, a as SinkCursorParams } from '../shared/indexer.d227f25c.mjs';
+import { S as Sink, b as SinkData, a as SinkCursorParams } from '../shared/indexer.b9c8f0d8.mjs';
 import { MockStreamResponse } from '@apibara/protocol/testing';
 import 'hookable';
 

package/dist/testing/index.d.ts

@@ -1,7 +1,8 @@
 import * as vitest from 'vitest';
-import { I as Indexer, j as VcrReplayResult } from '../shared/indexer.26fbe988.js';
+import { f as Indexer } from '../shared/indexer.f761abcd.js';
+import { a as VcrReplayResult } from '../shared/indexer.e4f2430f.js';
 import { Cursor } from '@apibara/protocol';
-import { b as Sink, S as SinkData, a as SinkCursorParams } from '../shared/indexer.d227f25c.js';
+import { S as Sink, b as SinkData, a as SinkCursorParams } from '../shared/indexer.b9c8f0d8.js';
 import { MockStreamResponse } from '@apibara/protocol/testing';
 import 'hookable';
 

package/dist/testing/index.mjs

@@ -1,18 +1,19 @@
 import { test as test$1 } from 'vitest';
-import { l as loadCassette, i as isCassetteAvailable, b as record, e as replay } from '../shared/indexer.28bd9576.mjs';
-export { V as VcrSink, v as vcr } from '../shared/indexer.28bd9576.mjs';
-import 'node:fs/promises';
-import 'node:path';
-import 'consola';
-import 'klona/full';
-import 'node:assert';
-import 'node:fs';
-import '@apibara/protocol/testing';
-import 'hookable';
+import { i as isCassetteAvailable } from '../shared/indexer.2c23c9cd.mjs';
+import { l as loadCassette, a as record, b as replay } from '../shared/indexer.36530330.mjs';
+export { V as VcrSink, v as vcr } from '../shared/indexer.36530330.mjs';
 import 'node:async_hooks';
 import 'unctx';
 import '@opentelemetry/api';
+import 'node:fs';
+import 'node:path';
+import 'node:fs/promises';
+import 'klona/full';
+import 'consola';
+import 'hookable';
+import 'node:assert';
 import '../shared/indexer.93d6b2eb.mjs';
+import '@apibara/protocol/testing';
 
 const test = test$1.extend({
   vcr: {

package/dist/vcr/index.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const helper = require('../shared/indexer.318d3617.cjs');
+const vcr_index = require('../shared/indexer.541d43eb.cjs');
+require('node:async_hooks');
+require('unctx');
+require('@opentelemetry/api');
+require('node:fs');
+require('node:path');
+require('node:fs/promises');
+require('klona/full');
+require('consola');
+require('hookable');
+require('node:assert');
+require('../shared/indexer.a8b7ab1f.cjs');
+require('@apibara/protocol/testing');
+
+
+
+exports.deserialize = helper.deserialize;
+exports.isCassetteAvailable = helper.isCassetteAvailable;
+exports.serialize = helper.serialize;
+exports.loadCassette = vcr_index.loadCassette;
+exports.record = vcr_index.record;
+exports.replay = vcr_index.replay;

package/dist/vcr/index.d.cts

@@ -0,0 +1,18 @@
+import { V as VcrConfig, C as CassetteOptions } from '../shared/indexer.500fd281.cjs';
+export { a as VcrReplayResult, l as loadCassette, r as replay } from '../shared/indexer.500fd281.cjs';
+import { StreamDataResponse, Client } from '@apibara/protocol';
+import { f as Indexer } from '../shared/indexer.c7ed6b83.cjs';
+import '../shared/indexer.b9c8f0d8.cjs';
+import 'hookable';
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+
+export { type CassetteDataType, CassetteOptions, VcrConfig, deserialize, isCassetteAvailable, record, serialize };

package/dist/vcr/index.d.mts

@@ -0,0 +1,18 @@
+import { V as VcrConfig, C as CassetteOptions } from '../shared/indexer.e1856641.mjs';
+export { a as VcrReplayResult, l as loadCassette, r as replay } from '../shared/indexer.e1856641.mjs';
+import { StreamDataResponse, Client } from '@apibara/protocol';
+import { f as Indexer } from '../shared/indexer.e8bd138d.mjs';
+import '../shared/indexer.b9c8f0d8.mjs';
+import 'hookable';
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+
+export { type CassetteDataType, CassetteOptions, VcrConfig, deserialize, isCassetteAvailable, record, serialize };

package/dist/vcr/index.d.ts

@@ -0,0 +1,18 @@
+import { V as VcrConfig, C as CassetteOptions } from '../shared/indexer.e4f2430f.js';
+export { a as VcrReplayResult, l as loadCassette, r as replay } from '../shared/indexer.e4f2430f.js';
+import { StreamDataResponse, Client } from '@apibara/protocol';
+import { f as Indexer } from '../shared/indexer.f761abcd.js';
+import '../shared/indexer.b9c8f0d8.js';
+import 'hookable';
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+
+export { type CassetteDataType, CassetteOptions, VcrConfig, deserialize, isCassetteAvailable, record, serialize };

package/dist/vcr/index.mjs

@@ -0,0 +1,14 @@
+export { d as deserialize, i as isCassetteAvailable, s as serialize } from '../shared/indexer.2c23c9cd.mjs';
+export { l as loadCassette, a as record, b as replay } from '../shared/indexer.36530330.mjs';
+import 'node:async_hooks';
+import 'unctx';
+import '@opentelemetry/api';
+import 'node:fs';
+import 'node:path';
+import 'node:fs/promises';
+import 'klona/full';
+import 'consola';
+import 'hookable';
+import 'node:assert';
+import '../shared/indexer.93d6b2eb.mjs';
+import '@apibara/protocol/testing';