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

package/dist/sinks/csv.d.cts

@@ -0,0 +1,66 @@
+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';
+
+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 { b as Sink, a as SinkCursorParams, S as SinkData } from '../shared/indexer.d227f25c.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 { b as Sink, a as SinkCursorParams, S as SinkData } from '../shared/indexer.d227f25c.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 };

package/dist/sinks/sqlite.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+const sink = require('../shared/indexer.a8b7ab1f.cjs');
+require('consola');
+
+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 SqliteSink extends sink.Sink {
+  constructor(options) {
+    super();
+    __publicField(this, "_config");
+    __publicField(this, "_db");
+    const { database, ...config } = options;
+    this._config = config;
+    this._db = database;
+  }
+  async write({
+    data,
+    endCursor
+  }) {
+    data = this.processCursorColumn(data, endCursor);
+    await this.insertJsonArray(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 insertJsonArray(data) {
+    if (data.length === 0)
+      return;
+    const columns = Object.keys(data[0]);
+    const columnNames = columns.join(", ");
+    const placeholders = columns.map(() => "?").join(", ");
+    const conflictClause = this.buildConflictClause();
+    const insertSQL = `INSERT INTO ${this._config.tableName} (${columnNames}) VALUES `;
+    const valuePlaceholders = data.map(() => `(${placeholders})`).join(", ");
+    const statement = insertSQL + valuePlaceholders + conflictClause;
+    const values = data.flatMap((row) => columns.map((col) => row[col]));
+    this._db.prepare(statement).run(values);
+  }
+  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)
+    }));
+  }
+  buildConflictClause() {
+    const { on, update } = this._config.onConflict || {};
+    if (on && update && update.length > 0) {
+      const updateColumns = update.map((col) => `${col}=excluded.${col}`).join(", ");
+      return ` ON CONFLICT(${on}) DO UPDATE SET ${updateColumns}`;
+    }
+    return "";
+  }
+}
+const sqlite = (args) => {
+  return new SqliteSink(args);
+};
+
+exports.SqliteSink = SqliteSink;
+exports.sqlite = sqlite;

package/dist/sinks/sqlite.d.cts

@@ -0,0 +1,71 @@
+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';
+
+type SqliteSinkOptions = {
+    /**
+     * Database instance of better-sqlite3
+     */
+    database: Database;
+    /**
+     * The name of the table where data will be inserted.
+     */
+    tableName: string;
+    /**
+     * 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;
+    /**
+     * An optional configuration to handle conflicts during data insertion.
+     * - `on`: The column name on which conflicts are detected.
+     * - `update`: An array of column names to be updated if a conflict occurs.
+     */
+    onConflict?: {
+        on: string;
+        update: string[];
+    };
+};
+type TxnParams = {
+    writer: {
+        insert: (data: SinkData[]) => void;
+    };
+};
+/**
+ * A sink that writes data to a SQLite database.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = sqlite({
+ *   database: db,
+ *   tableName: "test",
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { writer } = useSink(context);
+ *  const insertHelper = writer(endCursor);
+ *
+ *  insertHelper.insert([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class SqliteSink extends Sink {
+    private _config;
+    private _db;
+    constructor(options: SqliteSinkOptions);
+    private write;
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+    private insertJsonArray;
+    private processCursorColumn;
+    private buildConflictClause;
+}
+declare const sqlite: (args: SqliteSinkOptions) => SqliteSink;
+
+export { SqliteSink, type SqliteSinkOptions, sqlite };

package/dist/sinks/sqlite.d.mts

@@ -0,0 +1,71 @@
+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';
+
+type SqliteSinkOptions = {
+    /**
+     * Database instance of better-sqlite3
+     */
+    database: Database;
+    /**
+     * The name of the table where data will be inserted.
+     */
+    tableName: string;
+    /**
+     * 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;
+    /**
+     * An optional configuration to handle conflicts during data insertion.
+     * - `on`: The column name on which conflicts are detected.
+     * - `update`: An array of column names to be updated if a conflict occurs.
+     */
+    onConflict?: {
+        on: string;
+        update: string[];
+    };
+};
+type TxnParams = {
+    writer: {
+        insert: (data: SinkData[]) => void;
+    };
+};
+/**
+ * A sink that writes data to a SQLite database.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = sqlite({
+ *   database: db,
+ *   tableName: "test",
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { writer } = useSink(context);
+ *  const insertHelper = writer(endCursor);
+ *
+ *  insertHelper.insert([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class SqliteSink extends Sink {
+    private _config;
+    private _db;
+    constructor(options: SqliteSinkOptions);
+    private write;
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+    private insertJsonArray;
+    private processCursorColumn;
+    private buildConflictClause;
+}
+declare const sqlite: (args: SqliteSinkOptions) => SqliteSink;
+
+export { SqliteSink, type SqliteSinkOptions, sqlite };

package/dist/sinks/sqlite.d.ts

@@ -0,0 +1,71 @@
+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';
+
+type SqliteSinkOptions = {
+    /**
+     * Database instance of better-sqlite3
+     */
+    database: Database;
+    /**
+     * The name of the table where data will be inserted.
+     */
+    tableName: string;
+    /**
+     * 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;
+    /**
+     * An optional configuration to handle conflicts during data insertion.
+     * - `on`: The column name on which conflicts are detected.
+     * - `update`: An array of column names to be updated if a conflict occurs.
+     */
+    onConflict?: {
+        on: string;
+        update: string[];
+    };
+};
+type TxnParams = {
+    writer: {
+        insert: (data: SinkData[]) => void;
+    };
+};
+/**
+ * A sink that writes data to a SQLite database.
+ *
+ * @example
+ *
+ * ```ts
+ * const sink = sqlite({
+ *   database: db,
+ *   tableName: "test",
+ * });
+ *
+ * ...
+ * async transform({context, endCursor}){
+ *  const { writer } = useSink(context);
+ *  const insertHelper = writer(endCursor);
+ *
+ *  insertHelper.insert([
+ *    { id: 1, name: "John" },
+ *    { id: 2, name: "Jane" },
+ *  ]);
+ * }
+ *
+ * ```
+ */
+declare class SqliteSink extends Sink {
+    private _config;
+    private _db;
+    constructor(options: SqliteSinkOptions);
+    private write;
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+    private insertJsonArray;
+    private processCursorColumn;
+    private buildConflictClause;
+}
+declare const sqlite: (args: SqliteSinkOptions) => SqliteSink;
+
+export { SqliteSink, type SqliteSinkOptions, sqlite };

package/dist/sinks/sqlite.mjs

@@ -0,0 +1,87 @@
+import { S as Sink } from '../shared/indexer.93d6b2eb.mjs';
+import 'consola';
+
+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 SqliteSink extends Sink {
+  constructor(options) {
+    super();
+    __publicField(this, "_config");
+    __publicField(this, "_db");
+    const { database, ...config } = options;
+    this._config = config;
+    this._db = database;
+  }
+  async write({
+    data,
+    endCursor
+  }) {
+    data = this.processCursorColumn(data, endCursor);
+    await this.insertJsonArray(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 insertJsonArray(data) {
+    if (data.length === 0)
+      return;
+    const columns = Object.keys(data[0]);
+    const columnNames = columns.join(", ");
+    const placeholders = columns.map(() => "?").join(", ");
+    const conflictClause = this.buildConflictClause();
+    const insertSQL = `INSERT INTO ${this._config.tableName} (${columnNames}) VALUES `;
+    const valuePlaceholders = data.map(() => `(${placeholders})`).join(", ");
+    const statement = insertSQL + valuePlaceholders + conflictClause;
+    const values = data.flatMap((row) => columns.map((col) => row[col]));
+    this._db.prepare(statement).run(values);
+  }
+  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)
+    }));
+  }
+  buildConflictClause() {
+    const { on, update } = this._config.onConflict || {};
+    if (on && update && update.length > 0) {
+      const updateColumns = update.map((col) => `${col}=excluded.${col}`).join(", ");
+      return ` ON CONFLICT(${on}) DO UPDATE SET ${updateColumns}`;
+    }
+    return "";
+  }
+}
+const sqlite = (args) => {
+  return new SqliteSink(args);
+};
+
+export { SqliteSink, sqlite };