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

package/dist/shared/{indexer.99ec3128.cjs → indexer.541d43eb.cjs}

@@ -1,35 +1,23 @@
 'use strict';
 
-const fs$1 = require('node:fs/promises');
+const helper = require('./indexer.318d3617.cjs');
+const fs = require('node:fs/promises');
 const path = require('node:path');
-const consola = require('consola');
 const full = require('klona/full');
-const assert = require('node:assert');
-const fs = require('node:fs');
-const testing = require('@apibara/protocol/testing');
+const consola = require('consola');
 const hookable = require('hookable');
-const node_async_hooks = require('node:async_hooks');
-const unctx = require('unctx');
-const api = require('@opentelemetry/api');
+const assert = require('node:assert');
 const sink = require('./indexer.a8b7ab1f.cjs');
+const fs$1 = require('node:fs');
+const testing = require('@apibara/protocol/testing');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 const path__default = /*#__PURE__*/_interopDefaultCompat(path);
 const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
 const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
-const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-
-const indexerAsyncContext = unctx.getContext("indexer", {
-  asyncContext: true,
-  AsyncLocalStorage: node_async_hooks.AsyncLocalStorage
-});
-function useIndexerContext() {
-  return indexerAsyncContext.use();
-}
-
-const tracer = api.trace.getTracer("@apibara/indexer");
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
 
 function defineIndexer(streamConfig) {
   return (config) => ({
@@ -56,8 +44,8 @@ function createIndexer({
   return indexer;
 }
 async function run(client, indexer) {
-  await indexerAsyncContext.callAsync({}, async () => {
-    const context = useIndexerContext();
+  await helper.indexerAsyncContext.callAsync({}, async () => {
+    const context = helper.useIndexerContext();
     const sink$1 = indexer.options.sink ?? sink.defaultSink();
     context.sink = sink$1;
     await indexer.hooks.callHook("run:before");
@@ -83,7 +71,7 @@ async function run(client, indexer) {
       await indexer.hooks.callHook("message", { message });
       switch (message._tag) {
         case "data": {
-          await tracer.startActiveSpan("message data", async (span) => {
+          await helper.tracer.startActiveSpan("message data", async (span) => {
             const blocks = message.data.data;
             const { cursor, endCursor, finality } = message.data;
             await sink$1.transaction(
@@ -125,7 +113,7 @@ async function run(client, indexer) {
                   block = blocks[0];
                 }
                 if (block) {
-                  await tracer.startActiveSpan("handler", async (span2) => {
+                  await helper.tracer.startActiveSpan("handler", async (span2) => {
                     await indexer.hooks.callHook("handler:before", {
                       block,
                       endCursor,
@@ -165,7 +153,7 @@ async function run(client, indexer) {
           break;
         }
         case "invalidate": {
-          await tracer.startActiveSpan("message invalidate", async (span) => {
+          await helper.tracer.startActiveSpan("message invalidate", async (span) => {
             await sink$1.invalidate(message.invalidate.cursor);
           });
           break;
@@ -180,24 +168,6 @@ async function run(client, indexer) {
   });
 }
 
-function deserialize(str) {
-  return JSON.parse(
-    str,
-    (_, value) => typeof value === "string" && value.match(/^\d+n$/) ? BigInt(value.slice(0, -1)) : value
-  );
-}
-function serialize(obj) {
-  return JSON.stringify(
-    obj,
-    (_, value) => typeof value === "bigint" ? `${value.toString()}n` : value,
-    "	"
-  );
-}
-function isCassetteAvailable(vcrConfig, cassetteName) {
-  const filePath = path__default.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  return fs__default.existsSync(filePath);
-}
-
 async function record(vcrConfig, client, indexerArg, cassetteOptions) {
   const indexer = full.klona(indexerArg);
   const messages = [];
@@ -218,7 +188,7 @@ async function record(vcrConfig, client, indexerArg, cassetteOptions) {
         vcrConfig.cassetteDir,
         `${cassetteOptions.name}.json`
       );
-      await fs__default$1.writeFile(filePath, serialize(output), { flag: "w" });
+      await fs__default.writeFile(filePath, helper.serialize(output), { flag: "w" });
     }
   });
   await run(client, indexer);
@@ -273,8 +243,8 @@ async function replay(vcrConfig, indexer, cassetteName) {
 }
 function loadCassette(vcrConfig, cassetteName) {
   const filePath = path__default.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  const data = fs__default.readFileSync(filePath, "utf8");
-  const cassetteData = deserialize(data);
+  const data = fs__default$1.readFileSync(filePath, "utf8");
+  const cassetteData = helper.deserialize(data);
   const { filter, messages } = cassetteData;
   return new testing.MockClient((request, options) => {
     assert__default.deepStrictEqual(
@@ -289,12 +259,8 @@ function loadCassette(vcrConfig, cassetteName) {
 exports.VcrSink = VcrSink;
 exports.createIndexer = createIndexer;
 exports.defineIndexer = defineIndexer;
-exports.deserialize = deserialize;
-exports.isCassetteAvailable = isCassetteAvailable;
 exports.loadCassette = loadCassette;
 exports.record = record;
 exports.replay = replay;
 exports.run = run;
-exports.serialize = serialize;
-exports.useIndexerContext = useIndexerContext;
 exports.vcr = vcr;

package/dist/shared/{indexer.d227f25c.d.cts → indexer.b9c8f0d8.d.cts}

@@ -16,4 +16,4 @@ declare class DefaultSink extends Sink<unknown> {
 }
 declare function defaultSink(): DefaultSink;
 
-export { DefaultSink as D, type SinkData as S, type SinkCursorParams as a, Sink as b, defaultSink as d };
+export { DefaultSink as D, Sink as S, type SinkCursorParams as a, type SinkData as b, defaultSink as d };

package/dist/shared/{indexer.d227f25c.d.mts → indexer.b9c8f0d8.d.mts}

@@ -16,4 +16,4 @@ declare class DefaultSink extends Sink<unknown> {
 }
 declare function defaultSink(): DefaultSink;
 
-export { DefaultSink as D, type SinkData as S, type SinkCursorParams as a, Sink as b, defaultSink as d };
+export { DefaultSink as D, Sink as S, type SinkCursorParams as a, type SinkData as b, defaultSink as d };

package/dist/shared/{indexer.d227f25c.d.ts → indexer.b9c8f0d8.d.ts}

@@ -16,4 +16,4 @@ declare class DefaultSink extends Sink<unknown> {
 }
 declare function defaultSink(): DefaultSink;
 
-export { DefaultSink as D, type SinkData as S, type SinkCursorParams as a, Sink as b, defaultSink as d };
+export { DefaultSink as D, Sink as S, type SinkCursorParams as a, type SinkData as b, defaultSink as d };

package/dist/shared/{indexer.26fbe988.d.ts → indexer.c7ed6b83.d.cts}

@@ -1,6 +1,6 @@
 import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
 import { NestedHooks, Hookable } from 'hookable';
-import { b as Sink, S as SinkData } from './indexer.d227f25c.js';
+import { S as Sink } from './indexer.b9c8f0d8.cjs';
 
 interface IndexerContext<TTxnParams = any> extends Record<string, any> {
     sink?: Sink<TTxnParams>;
@@ -79,22 +79,4 @@ interface Indexer<TFilter, TBlock, TTxnParams> {
 declare function createIndexer<TFilter, TBlock, TTxnParams>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock, TTxnParams>): Indexer<TFilter, TBlock, TTxnParams>;
 declare function run<TFilter, TBlock, TTxnParams>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock, TTxnParams>): Promise<void>;
 
-type VcrConfig = {
-    cassetteDir: string;
-};
-type CassetteOptions = {
-    name: string;
-    startingCursor: Cursor;
-    endingCursor: Cursor;
-};
-
-declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TTxnParams>, cassetteName: string): Promise<VcrReplayResult>;
-type VcrReplayResult = {
-    outputs: Array<{
-        endCursor?: Cursor;
-        data: SinkData[];
-    }>;
-};
-declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
-
-export { type CassetteOptions as C, type Indexer as I, type VcrConfig as V, type IndexerContext as a, type IndexerHooks as b, type IndexerConfig as c, type IndexerWithStreamConfig as d, defineIndexer as e, createIndexer as f, type IndexerPlugin as g, defineIndexerPlugin as h, replay as i, type VcrReplayResult as j, loadCassette as l, run as r, useIndexerContext as u };
+export { type IndexerPlugin as I, type IndexerContext as a, type IndexerHooks as b, type IndexerConfig as c, type IndexerWithStreamConfig as d, defineIndexer as e, type Indexer as f, createIndexer as g, defineIndexerPlugin as h, run as r, useIndexerContext as u };

package/dist/shared/indexer.e1856641.d.mts

@@ -0,0 +1,23 @@
+import { Cursor, Client } from '@apibara/protocol';
+import { f as Indexer } from './indexer.e8bd138d.mjs';
+import { b as SinkData } from './indexer.b9c8f0d8.mjs';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TTxnParams>, cassetteName: string): Promise<VcrReplayResult>;
+type VcrReplayResult = {
+    outputs: Array<{
+        endCursor?: Cursor;
+        data: SinkData[];
+    }>;
+};
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteOptions as C, type VcrConfig as V, type VcrReplayResult as a, loadCassette as l, replay as r };

package/dist/shared/indexer.e4f2430f.d.ts

@@ -0,0 +1,23 @@
+import { Cursor, Client } from '@apibara/protocol';
+import { f as Indexer } from './indexer.f761abcd.js';
+import { b as SinkData } from './indexer.b9c8f0d8.js';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TTxnParams>, cassetteName: string): Promise<VcrReplayResult>;
+type VcrReplayResult = {
+    outputs: Array<{
+        endCursor?: Cursor;
+        data: SinkData[];
+    }>;
+};
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteOptions as C, type VcrConfig as V, type VcrReplayResult as a, loadCassette as l, replay as r };

package/dist/shared/{indexer.ff960804.d.cts → indexer.e8bd138d.d.mts}

@@ -1,6 +1,6 @@
 import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
 import { NestedHooks, Hookable } from 'hookable';
-import { b as Sink, S as SinkData } from './indexer.d227f25c.cjs';
+import { S as Sink } from './indexer.b9c8f0d8.mjs';
 
 interface IndexerContext<TTxnParams = any> extends Record<string, any> {
     sink?: Sink<TTxnParams>;
@@ -79,22 +79,4 @@ interface Indexer<TFilter, TBlock, TTxnParams> {
 declare function createIndexer<TFilter, TBlock, TTxnParams>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock, TTxnParams>): Indexer<TFilter, TBlock, TTxnParams>;
 declare function run<TFilter, TBlock, TTxnParams>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock, TTxnParams>): Promise<void>;
 
-type VcrConfig = {
-    cassetteDir: string;
-};
-type CassetteOptions = {
-    name: string;
-    startingCursor: Cursor;
-    endingCursor: Cursor;
-};
-
-declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TTxnParams>, cassetteName: string): Promise<VcrReplayResult>;
-type VcrReplayResult = {
-    outputs: Array<{
-        endCursor?: Cursor;
-        data: SinkData[];
-    }>;
-};
-declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
-
-export { type CassetteOptions as C, type Indexer as I, type VcrConfig as V, type IndexerContext as a, type IndexerHooks as b, type IndexerConfig as c, type IndexerWithStreamConfig as d, defineIndexer as e, createIndexer as f, type IndexerPlugin as g, defineIndexerPlugin as h, replay as i, type VcrReplayResult as j, loadCassette as l, run as r, useIndexerContext as u };
+export { type IndexerPlugin as I, type IndexerContext as a, type IndexerHooks as b, type IndexerConfig as c, type IndexerWithStreamConfig as d, defineIndexer as e, type Indexer as f, createIndexer as g, defineIndexerPlugin as h, run as r, useIndexerContext as u };

package/dist/shared/{indexer.9aa22867.d.mts → indexer.f761abcd.d.ts}

@@ -1,6 +1,6 @@
 import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
 import { NestedHooks, Hookable } from 'hookable';
-import { b as Sink, S as SinkData } from './indexer.d227f25c.mjs';
+import { S as Sink } from './indexer.b9c8f0d8.js';
 
 interface IndexerContext<TTxnParams = any> extends Record<string, any> {
     sink?: Sink<TTxnParams>;
@@ -79,22 +79,4 @@ interface Indexer<TFilter, TBlock, TTxnParams> {
 declare function createIndexer<TFilter, TBlock, TTxnParams>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock, TTxnParams>): Indexer<TFilter, TBlock, TTxnParams>;
 declare function run<TFilter, TBlock, TTxnParams>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock, TTxnParams>): Promise<void>;
 
-type VcrConfig = {
-    cassetteDir: string;
-};
-type CassetteOptions = {
-    name: string;
-    startingCursor: Cursor;
-    endingCursor: Cursor;
-};
-
-declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TTxnParams>, cassetteName: string): Promise<VcrReplayResult>;
-type VcrReplayResult = {
-    outputs: Array<{
-        endCursor?: Cursor;
-        data: SinkData[];
-    }>;
-};
-declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
-
-export { type CassetteOptions as C, type Indexer as I, type VcrConfig as V, type IndexerContext as a, type IndexerHooks as b, type IndexerConfig as c, type IndexerWithStreamConfig as d, defineIndexer as e, createIndexer as f, type IndexerPlugin as g, defineIndexerPlugin as h, replay as i, type VcrReplayResult as j, loadCassette as l, run as r, useIndexerContext as u };
+export { type IndexerPlugin as I, type IndexerContext as a, type IndexerHooks as b, type IndexerConfig as c, type IndexerWithStreamConfig as d, defineIndexer as e, type Indexer as f, createIndexer as g, defineIndexerPlugin as h, run as r, useIndexerContext as u };

package/dist/sinks/csv.d.cts

@@ -1,6 +1,6 @@
 import { Cursor } from '@apibara/protocol';
 import { Options, Stringifier } from 'csv-stringify';
-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 CsvArgs = {
     /**

package/dist/sinks/csv.d.mts

@@ -1,6 +1,6 @@
 import { Cursor } from '@apibara/protocol';
 import { Options, Stringifier } from 'csv-stringify';
-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 CsvArgs = {
     /**

package/dist/sinks/csv.d.ts

@@ -1,6 +1,6 @@
 import { Cursor } from '@apibara/protocol';
 import { Options, Stringifier } from 'csv-stringify';
-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 CsvArgs = {
     /**

package/dist/sinks/drizzle/index.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+const drizzleOrm = require('drizzle-orm');
+const sink = require('../../shared/indexer.a8b7ab1f.cjs');
+const pgCore = require('drizzle-orm/pg-core');
+const range = require('postgres-range');
+require('consola');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const range__default = /*#__PURE__*/_interopDefaultCompat(range);
+
+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: drizzleOrm.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 = pgCore.customType({
+  dataType: () => "int8range",
+  fromDriver: (value) => {
+    if (typeof value !== "string") {
+      throw new Error("Expected string");
+    }
+    const parsed = range.parse(value, (val) => Number.parseInt(val, 10));
+    return new Int8Range(parsed);
+  },
+  toDriver: (value) => range.serialize(value.range)
+});
+
+const pgTable = (name, columns, extraConfig) => {
+  return pgCore.pgTable(
+    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__default.Range(
+      Number(lower),
+      Number(upper),
+      range__default.RANGE_LB_INC | (isNoUpperBound ? range__default.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 = drizzleOrm.sql`${where ? drizzleOrm.sql`${where} AND ` : drizzleOrm.sql``}upper_inf(_cursor)`;
+          return originalFrom.where(combinedWhere);
+        }
+      };
+    }
+    return this.db.select().from(source).where(drizzleOrm.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: drizzleOrm.sql`int8range(lower(_cursor), ${Number(this.endCursor?.orderKey)}, '[)')`
+        }).where(drizzleOrm.sql`${where ? drizzleOrm.sql`${where} AND ` : drizzleOrm.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.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(drizzleOrm.gt(drizzleOrm.sql`lower(_cursor)`, drizzleOrm.sql`${Number(cursor?.orderKey)}`)).returning();
+        await db.update(table).set({
+          _cursor: drizzleOrm.sql`int8range(lower(_cursor), NULL, '[)')`
+        }).where(drizzleOrm.gt(drizzleOrm.sql`upper(_cursor)`, drizzleOrm.sql`${Number(cursor?.orderKey)}`));
+      }
+    });
+  }
+}
+const drizzle = (args) => {
+  return new DrizzleSink(args);
+};
+
+exports.DrizzleSink = DrizzleSink;
+exports.DrizzleSinkDelete = DrizzleSinkDelete;
+exports.DrizzleSinkTransaction = DrizzleSinkTransaction;
+exports.DrizzleSinkUpdate = DrizzleSinkUpdate;
+exports.Int8Range = Int8Range;
+exports.drizzle = drizzle;
+exports.getDrizzleCursor = getDrizzleCursor;
+exports.int8range = int8range;
+exports.pgTable = pgTable;

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

@@ -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.cjs';
+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 };