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

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 };

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

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

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

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