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

package/dist/shared/indexer.99ec3128.cjs

@@ -0,0 +1,300 @@
+'use strict';
+
+const fs$1 = 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 hookable = require('hookable');
+const node_async_hooks = require('node:async_hooks');
+const unctx = require('unctx');
+const api = require('@opentelemetry/api');
+const sink = require('./indexer.a8b7ab1f.cjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+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");
+
+function defineIndexer(streamConfig) {
+  return (config) => ({
+    streamConfig,
+    ...config
+  });
+}
+function createIndexer({
+  streamConfig,
+  ...options
+}) {
+  const indexer = {
+    options,
+    streamConfig,
+    hooks: hookable.createHooks()
+  };
+  if (indexer.options.debug) {
+    hookable.createDebugger(indexer.hooks, { tag: "indexer" });
+  }
+  indexer.hooks.addHooks(indexer.options.hooks ?? {});
+  for (const plugin of indexer.options.plugins ?? []) {
+    plugin(indexer);
+  }
+  return indexer;
+}
+async function run(client, indexer) {
+  await indexerAsyncContext.callAsync({}, async () => {
+    const context = useIndexerContext();
+    const sink$1 = indexer.options.sink ?? sink.defaultSink();
+    context.sink = sink$1;
+    await indexer.hooks.callHook("run:before");
+    const isFactoryMode = indexer.options.factory !== void 0;
+    const request = indexer.streamConfig.Request.make({
+      filter: isFactoryMode ? [indexer.options.filter, {}] : [indexer.options.filter],
+      finality: indexer.options.finality,
+      startingCursor: indexer.options.startingCursor
+    });
+    const options = {};
+    await indexer.hooks.callHook("connect:before", { request, options });
+    let mainFilter;
+    if (isFactoryMode) {
+      mainFilter = request.filter[1];
+    }
+    let stream = client.streamData(request, options)[Symbol.asyncIterator]();
+    await indexer.hooks.callHook("connect:after");
+    while (true) {
+      const { value: message, done } = await stream.next();
+      if (done) {
+        break;
+      }
+      await indexer.hooks.callHook("message", { message });
+      switch (message._tag) {
+        case "data": {
+          await tracer.startActiveSpan("message data", async (span) => {
+            const blocks = message.data.data;
+            const { cursor, endCursor, finality } = message.data;
+            await sink$1.transaction(
+              { cursor, endCursor, finality },
+              async (txn) => {
+                context.sinkTransaction = txn;
+                let block;
+                if (isFactoryMode) {
+                  assert__default(indexer.options.factory !== void 0);
+                  const [factoryBlock, mainBlock] = blocks;
+                  block = mainBlock;
+                  if (factoryBlock !== null) {
+                    const { filter } = await indexer.options.factory({
+                      block: factoryBlock,
+                      context
+                    });
+                    if (filter) {
+                      mainFilter = indexer.streamConfig.mergeFilter(
+                        mainFilter,
+                        filter
+                      );
+                      const request2 = indexer.streamConfig.Request.make({
+                        filter: [indexer.options.filter, mainFilter],
+                        finality: indexer.options.finality,
+                        startingCursor: cursor
+                      });
+                      await indexer.hooks.callHook("connect:factory", {
+                        request: request2,
+                        endCursor
+                      });
+                      stream = client.streamData(request2, options)[Symbol.asyncIterator]();
+                      const { value: message2 } = await stream.next();
+                      assert__default(message2._tag === "data");
+                      const [_factoryBlock, _block] = message2.data.data;
+                      block = _block;
+                    }
+                  }
+                } else {
+                  block = blocks[0];
+                }
+                if (block) {
+                  await tracer.startActiveSpan("handler", async (span2) => {
+                    await indexer.hooks.callHook("handler:before", {
+                      block,
+                      endCursor,
+                      finality
+                    });
+                    try {
+                      await indexer.options.transform({
+                        block,
+                        cursor,
+                        endCursor,
+                        finality,
+                        context
+                      });
+                      await indexer.hooks.callHook("handler:after", {
+                        block,
+                        finality,
+                        endCursor
+                      });
+                    } catch (error) {
+                      assert__default(error instanceof Error);
+                      await indexer.hooks.callHook("handler:exception", {
+                        error
+                      });
+                      throw error;
+                    }
+                    span2.end();
+                  });
+                }
+              }
+            );
+            await indexer.hooks.callHook("transaction:commit", {
+              finality,
+              endCursor
+            });
+            span.end();
+          });
+          break;
+        }
+        case "invalidate": {
+          await tracer.startActiveSpan("message invalidate", async (span) => {
+            await sink$1.invalidate(message.invalidate.cursor);
+          });
+          break;
+        }
+        default: {
+          consola__default.warn("unexpected message", message);
+          throw new Error("not implemented");
+        }
+      }
+      await indexer.hooks.callHook("run:after");
+    }
+  });
+}
+
+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 = [];
+  indexer.hooks.addHooks({
+    "connect:before"({ options, request }) {
+      request.startingCursor = cassetteOptions.startingCursor;
+      options.endingCursor = cassetteOptions.endingCursor;
+    },
+    message({ message }) {
+      messages.push(message);
+    },
+    async "run:after"() {
+      const output = {
+        filter: indexer.options.filter,
+        messages
+      };
+      const filePath = path__default.join(
+        vcrConfig.cassetteDir,
+        `${cassetteOptions.name}.json`
+      );
+      await fs__default$1.writeFile(filePath, serialize(output), { flag: "w" });
+    }
+  });
+  await run(client, indexer);
+}
+
+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;
+};
+const transactionHelper = (context) => {
+  return {
+    insert: (data) => {
+      context.buffer.push(...data);
+    }
+  };
+};
+class VcrSink extends sink.Sink {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "result", []);
+  }
+  write({ data, endCursor }) {
+    if (data.length === 0)
+      return;
+    this.result.push({ data, endCursor });
+  }
+  async transaction({ cursor, endCursor, finality }, cb) {
+    const context = {
+      buffer: []
+    };
+    const writer = transactionHelper(context);
+    await cb({ writer });
+    this.write({ data: context.buffer, endCursor });
+  }
+  async invalidate(cursor) {
+    throw new Error("Not implemented");
+  }
+}
+function vcr() {
+  return new VcrSink();
+}
+
+async function replay(vcrConfig, indexer, cassetteName) {
+  const client = loadCassette(vcrConfig, cassetteName);
+  const sink = vcr();
+  await run(client, indexer);
+  return {
+    outputs: sink.result
+  };
+}
+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 { filter, messages } = cassetteData;
+  return new testing.MockClient((request, options) => {
+    assert__default.deepStrictEqual(
+      request.filter,
+      filter,
+      "Request and Cassette filter mismatch"
+    );
+    return messages;
+  });
+}
+
+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.9aa22867.d.mts

@@ -0,0 +1,100 @@
+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';
+
+interface IndexerContext<TTxnParams = any> extends Record<string, any> {
+    sink?: Sink<TTxnParams>;
+    sinkTransaction?: TTxnParams;
+}
+declare function useIndexerContext<TTxnParams = any>(): IndexerContext<TTxnParams>;
+
+type IndexerPlugin<TFilter, TBlock, TTxnParams> = (indexer: Indexer<TFilter, TBlock, TTxnParams>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock, TTxnParams>(def: IndexerPlugin<TFilter, TBlock, TTxnParams>): IndexerPlugin<TFilter, TBlock, TTxnParams>;
+
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": () => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:before": ({ block, finality, endCursor, }: {
+        block: TBlock;
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:after": ({ block, finality, endCursor, }: {
+        block: TBlock;
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "transaction:commit": ({ finality, endCursor, }: {
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:exception": ({ error }: {
+        error: Error;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+}
+interface IndexerConfig<TFilter, TBlock, TTxnParams> {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    startingCursor?: Cursor;
+    sink?: Sink<TTxnParams>;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext<TTxnParams>;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext<TTxnParams>;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock, TTxnParams>>;
+    debug?: boolean;
+}
+interface IndexerWithStreamConfig<TFilter, TBlock, TTxnParams> extends IndexerConfig<TFilter, TBlock, TTxnParams> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+}
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): <TTxnParams>(config: IndexerConfig<TFilter, TBlock, TTxnParams>) => IndexerWithStreamConfig<TFilter, TBlock, TTxnParams>;
+interface Indexer<TFilter, TBlock, TTxnParams> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock, TTxnParams>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+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 };

package/dist/shared/indexer.a8b7ab1f.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const consola = require('consola');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
+
+class Sink {
+}
+class DefaultSink extends Sink {
+  async transaction({ cursor, endCursor, finality }, cb) {
+    await cb({});
+  }
+  async invalidate(cursor) {
+    consola__default.info(`Invalidating cursor ${cursor?.orderKey}`);
+  }
+}
+function defaultSink() {
+  return new DefaultSink();
+}
+
+exports.DefaultSink = DefaultSink;
+exports.Sink = Sink;
+exports.defaultSink = defaultSink;

package/dist/shared/indexer.d227f25c.d.cts

@@ -0,0 +1,19 @@
+import { Cursor, DataFinality } from '@apibara/protocol';
+
+type SinkData = Record<string, unknown>;
+type SinkCursorParams = {
+    cursor?: Cursor;
+    endCursor?: Cursor;
+    finality: DataFinality;
+};
+declare abstract class Sink<TTxnParams = unknown> {
+    abstract transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TTxnParams) => Promise<void>): Promise<void>;
+    abstract invalidate(cursor?: Cursor): Promise<void>;
+}
+declare class DefaultSink extends Sink<unknown> {
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: unknown) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare function defaultSink(): DefaultSink;
+
+export { DefaultSink as D, type SinkData as S, type SinkCursorParams as a, Sink as b, defaultSink as d };

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

@@ -0,0 +1,19 @@
+import { Cursor, DataFinality } from '@apibara/protocol';
+
+type SinkData = Record<string, unknown>;
+type SinkCursorParams = {
+    cursor?: Cursor;
+    endCursor?: Cursor;
+    finality: DataFinality;
+};
+declare abstract class Sink<TTxnParams = unknown> {
+    abstract transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TTxnParams) => Promise<void>): Promise<void>;
+    abstract invalidate(cursor?: Cursor): Promise<void>;
+}
+declare class DefaultSink extends Sink<unknown> {
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: unknown) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare function defaultSink(): DefaultSink;
+
+export { DefaultSink as D, type SinkData as S, type SinkCursorParams as a, Sink as b, defaultSink as d };

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

@@ -0,0 +1,19 @@
+import { Cursor, DataFinality } from '@apibara/protocol';
+
+type SinkData = Record<string, unknown>;
+type SinkCursorParams = {
+    cursor?: Cursor;
+    endCursor?: Cursor;
+    finality: DataFinality;
+};
+declare abstract class Sink<TTxnParams = unknown> {
+    abstract transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TTxnParams) => Promise<void>): Promise<void>;
+    abstract invalidate(cursor?: Cursor): Promise<void>;
+}
+declare class DefaultSink extends Sink<unknown> {
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: unknown) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare function defaultSink(): DefaultSink;
+
+export { DefaultSink as D, type SinkData as S, type SinkCursorParams as a, Sink as b, defaultSink as d };

package/dist/shared/indexer.ff960804.d.cts

@@ -0,0 +1,100 @@
+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';
+
+interface IndexerContext<TTxnParams = any> extends Record<string, any> {
+    sink?: Sink<TTxnParams>;
+    sinkTransaction?: TTxnParams;
+}
+declare function useIndexerContext<TTxnParams = any>(): IndexerContext<TTxnParams>;
+
+type IndexerPlugin<TFilter, TBlock, TTxnParams> = (indexer: Indexer<TFilter, TBlock, TTxnParams>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock, TTxnParams>(def: IndexerPlugin<TFilter, TBlock, TTxnParams>): IndexerPlugin<TFilter, TBlock, TTxnParams>;
+
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": () => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:before": ({ block, finality, endCursor, }: {
+        block: TBlock;
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:after": ({ block, finality, endCursor, }: {
+        block: TBlock;
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "transaction:commit": ({ finality, endCursor, }: {
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:exception": ({ error }: {
+        error: Error;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+}
+interface IndexerConfig<TFilter, TBlock, TTxnParams> {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    startingCursor?: Cursor;
+    sink?: Sink<TTxnParams>;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext<TTxnParams>;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext<TTxnParams>;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock, TTxnParams>>;
+    debug?: boolean;
+}
+interface IndexerWithStreamConfig<TFilter, TBlock, TTxnParams> extends IndexerConfig<TFilter, TBlock, TTxnParams> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+}
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): <TTxnParams>(config: IndexerConfig<TFilter, TBlock, TTxnParams>) => IndexerWithStreamConfig<TFilter, TBlock, TTxnParams>;
+interface Indexer<TFilter, TBlock, TTxnParams> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock, TTxnParams>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+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 };

package/dist/sinks/csv.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+const fs = require('node:fs');
+const csvStringify = require('csv-stringify');
+const sink = require('../shared/indexer.a8b7ab1f.cjs');
+require('consola');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+const transactionHelper = (context) => {
+  return {
+    insert: (data) => {
+      context.buffer.push(...data);
+    }
+  };
+};
+class CsvSink extends sink.Sink {
+  constructor(_stringifier, _config) {
+    super();
+    this._stringifier = _stringifier;
+    this._config = _config;
+  }
+  async write({
+    data,
+    endCursor
+  }) {
+    data = this.processCursorColumn(data, endCursor);
+    await this.insertToCSV(data);
+  }
+  async transaction({ cursor, endCursor, finality }, cb) {
+    const context = {
+      buffer: []
+    };
+    const writer = transactionHelper(context);
+    await cb({ writer });
+    await this.write({ data: context.buffer, endCursor });
+  }
+  async invalidate(cursor) {
+    throw new Error("Not implemented");
+  }
+  async insertToCSV(data) {
+    if (data.length === 0)
+      return;
+    return await new Promise((resolve, reject) => {
+      for (const row of data) {
+        this._stringifier.write(row, (err) => {
+          if (err)
+            throw new Error(err.message);
+          if (row === data[data.length - 1]) {
+            resolve();
+          }
+        });
+      }
+    });
+  }
+  processCursorColumn(data, endCursor) {
+    const { cursorColumn } = this._config;
+    if (cursorColumn && data.some(
+      (row) => Number(row[cursorColumn]) !== Number(endCursor?.orderKey)
+    )) {
+      throw new Error(
+        `Mismatch of ${cursorColumn} and Cursor ${Number(endCursor?.orderKey)}`
+      );
+    }
+    if (cursorColumn) {
+      return data;
+    }
+    return data.map((row) => ({
+      ...row,
+      _cursor: Number(endCursor?.orderKey)
+    }));
+  }
+}
+const csv = (args) => {
+  const { csvOptions, filepath, ...sinkOptions } = args;
+  const stringifier = csvStringify.stringify({ ...csvOptions });
+  const writeStream = fs__default.createWriteStream(filepath, { flags: "a" });
+  stringifier.pipe(writeStream);
+  return new CsvSink(stringifier, sinkOptions);
+};
+
+exports.CsvSink = CsvSink;
+exports.csv = csv;