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

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

@@ -0,0 +1,82 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+import { S as Sink } from './indexer.b9c8f0d8.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>;
+
+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.e8bd138d.d.mts

@@ -0,0 +1,82 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+import { S as Sink } from './indexer.b9c8f0d8.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>;
+
+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.f761abcd.d.ts

@@ -0,0 +1,82 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+import { S as Sink } from './indexer.b9c8f0d8.js';
+
+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>;
+
+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.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;

package/dist/sinks/csv.d.cts

@@ -0,0 +1,66 @@
+import { Cursor } from '@apibara/protocol';
+import { Options, Stringifier } from 'csv-stringify';
+import { S as Sink, a as SinkCursorParams, b as SinkData } from '../shared/indexer.b9c8f0d8.cjs';
+
+type CsvArgs = {
+    /**
+     * csv-stringy options
+     * @reference https://csv.js.org/stringify/options/
+     */
+    csvOptions?: Options;
+    /**
+     * filepath for your csv file
+     */
+    filepath: string;
+};
+type CsvSinkOptions = {
+    /**
+     * An optional column name used to store the cursor value. If specified,
+     * the value of this column must match the `endCursor.orderKey` for each row.
+     */
+    cursorColumn?: string;
+};
+type TxnParams = {
+    writer: {
+        insert: (data: SinkData[]) => void;
+    };
+};
+/**
+ * A sink that writes data to a CSV file.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = csv({
+ *   filepath: "./data.csv",
+ *   csvOptions: {
+ *     header: true,
+ *   },
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { writer } = useSink(context);
+ *  const insertHelper = writer(endCursor);
+ *
+ *  insertHelper.insert([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class CsvSink extends Sink {
+    private _stringifier;
+    private _config;
+    constructor(_stringifier: Stringifier, _config: CsvSinkOptions);
+    private write;
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+    private insertToCSV;
+    private processCursorColumn;
+}
+declare const csv: (args: CsvArgs & CsvSinkOptions) => CsvSink;
+
+export { type CsvArgs, CsvSink, type CsvSinkOptions, csv };

package/dist/sinks/csv.d.mts

@@ -0,0 +1,66 @@
+import { Cursor } from '@apibara/protocol';
+import { Options, Stringifier } from 'csv-stringify';
+import { S as Sink, a as SinkCursorParams, b as SinkData } from '../shared/indexer.b9c8f0d8.mjs';
+
+type CsvArgs = {
+    /**
+     * csv-stringy options
+     * @reference https://csv.js.org/stringify/options/
+     */
+    csvOptions?: Options;
+    /**
+     * filepath for your csv file
+     */
+    filepath: string;
+};
+type CsvSinkOptions = {
+    /**
+     * An optional column name used to store the cursor value. If specified,
+     * the value of this column must match the `endCursor.orderKey` for each row.
+     */
+    cursorColumn?: string;
+};
+type TxnParams = {
+    writer: {
+        insert: (data: SinkData[]) => void;
+    };
+};
+/**
+ * A sink that writes data to a CSV file.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = csv({
+ *   filepath: "./data.csv",
+ *   csvOptions: {
+ *     header: true,
+ *   },
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { writer } = useSink(context);
+ *  const insertHelper = writer(endCursor);
+ *
+ *  insertHelper.insert([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class CsvSink extends Sink {
+    private _stringifier;
+    private _config;
+    constructor(_stringifier: Stringifier, _config: CsvSinkOptions);
+    private write;
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+    private insertToCSV;
+    private processCursorColumn;
+}
+declare const csv: (args: CsvArgs & CsvSinkOptions) => CsvSink;
+
+export { type CsvArgs, CsvSink, type CsvSinkOptions, csv };

package/dist/sinks/csv.d.ts

@@ -0,0 +1,66 @@
+import { Cursor } from '@apibara/protocol';
+import { Options, Stringifier } from 'csv-stringify';
+import { S as Sink, a as SinkCursorParams, b as SinkData } from '../shared/indexer.b9c8f0d8.js';
+
+type CsvArgs = {
+    /**
+     * csv-stringy options
+     * @reference https://csv.js.org/stringify/options/
+     */
+    csvOptions?: Options;
+    /**
+     * filepath for your csv file
+     */
+    filepath: string;
+};
+type CsvSinkOptions = {
+    /**
+     * An optional column name used to store the cursor value. If specified,
+     * the value of this column must match the `endCursor.orderKey` for each row.
+     */
+    cursorColumn?: string;
+};
+type TxnParams = {
+    writer: {
+        insert: (data: SinkData[]) => void;
+    };
+};
+/**
+ * A sink that writes data to a CSV file.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = csv({
+ *   filepath: "./data.csv",
+ *   csvOptions: {
+ *     header: true,
+ *   },
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { writer } = useSink(context);
+ *  const insertHelper = writer(endCursor);
+ *
+ *  insertHelper.insert([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class CsvSink extends Sink {
+    private _stringifier;
+    private _config;
+    constructor(_stringifier: Stringifier, _config: CsvSinkOptions);
+    private write;
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+    private insertToCSV;
+    private processCursorColumn;
+}
+declare const csv: (args: CsvArgs & CsvSinkOptions) => CsvSink;
+
+export { type CsvArgs, CsvSink, type CsvSinkOptions, csv };

package/dist/sinks/csv.mjs

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import { stringify } from 'csv-stringify';
+import { S as Sink } from '../shared/indexer.93d6b2eb.mjs';
+import 'consola';
+
+const transactionHelper = (context) => {
+  return {
+    insert: (data) => {
+      context.buffer.push(...data);
+    }
+  };
+};
+class CsvSink extends 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 = stringify({ ...csvOptions });
+  const writeStream = fs.createWriteStream(filepath, { flags: "a" });
+  stringifier.pipe(writeStream);
+  return new CsvSink(stringifier, sinkOptions);
+};
+
+export { CsvSink, csv };