@apibara/plugin-drizzle 2.1.0-beta.14 → 2.1.0-beta.16

package/dist/index.cjs

@@ -4,7 +4,7 @@ const indexer = require('@apibara/indexer');
 const plugins = require('@apibara/indexer/plugins');
 const internal = require('@apibara/indexer/internal');
 const plugins$1 = require('@apibara/indexer/internal/plugins');
-const constants = require('./shared/plugin-drizzle.e884ca32.cjs');
+const constants = require('./shared/plugin-drizzle.cae20704.cjs');
 const pglite$1 = require('@electric-sql/pglite');
 const nodePostgres = require('drizzle-orm/node-postgres');
 const migrator$1 = require('drizzle-orm/node-postgres/migrator');
@@ -49,7 +49,7 @@ function sleep(ms) {
 
 function drizzle(options) {
   const {
-    connectionString = "memory://",
+    connectionString = process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://",
     schema,
     type = "pglite",
     config,
@@ -91,15 +91,16 @@ async function migrate(db, options) {
   }
 }
 
-const CHECKPOINTS_TABLE_NAME = "__indexer_checkpoints";
-const FILTERS_TABLE_NAME = "__indexer_filters";
-const SCHEMA_VERSION_TABLE_NAME = "__indexer_schema_version";
-const checkpoints = pgCore.pgTable(CHECKPOINTS_TABLE_NAME, {
+const CHECKPOINTS_TABLE_NAME = "checkpoints";
+const FILTERS_TABLE_NAME = "filters";
+const SCHEMA_VERSION_TABLE_NAME = "schema_version";
+const schema$1 = pgCore.pgSchema(constants.SCHEMA_NAME);
+const checkpoints = schema$1.table(CHECKPOINTS_TABLE_NAME, {
   id: pgCore.text("id").notNull().primaryKey(),
   orderKey: pgCore.integer("order_key").notNull(),
   uniqueKey: pgCore.text("unique_key")
 });
-const filters = pgCore.pgTable(
+const filters = schema$1.table(
   FILTERS_TABLE_NAME,
   {
     id: pgCore.text("id").notNull(),
@@ -113,7 +114,7 @@ const filters = pgCore.pgTable(
     }
   ]
 );
-const schemaVersion = pgCore.pgTable(SCHEMA_VERSION_TABLE_NAME, {
+const schemaVersion = schema$1.table(SCHEMA_VERSION_TABLE_NAME, {
   k: pgCore.integer("k").notNull().primaryKey(),
   version: pgCore.integer("version").notNull()
 });
@@ -124,12 +125,19 @@ const MIGRATIONS = [
   // Add more migration arrays for future versions
 ];
 async function initializePersistentState(tx) {
-  await tx.execute(`
-    CREATE TABLE IF NOT EXISTS ${SCHEMA_VERSION_TABLE_NAME} (
+  await tx.execute(
+    drizzleOrm.sql.raw(`
+      CREATE SCHEMA IF NOT EXISTS ${constants.SCHEMA_NAME};
+  `)
+  );
+  await tx.execute(
+    drizzleOrm.sql.raw(`
+    CREATE TABLE IF NOT EXISTS ${constants.SCHEMA_NAME}.${SCHEMA_VERSION_TABLE_NAME} (
       k INTEGER PRIMARY KEY,
       version INTEGER NOT NULL
     );
-  `);
+  `)
+  );
   const versionRows = await tx.select().from(schemaVersion).where(drizzleOrm.eq(schemaVersion.k, 0));
   const storedVersion = versionRows[0]?.version ?? -1;
   if (storedVersion > CURRENT_SCHEMA_VERSION) {
@@ -139,22 +147,26 @@ async function initializePersistentState(tx) {
   }
   try {
     if (storedVersion === -1) {
-      await tx.execute(`
-        CREATE TABLE IF NOT EXISTS ${CHECKPOINTS_TABLE_NAME} (
+      await tx.execute(
+        drizzleOrm.sql.raw(`
+        CREATE TABLE IF NOT EXISTS ${constants.SCHEMA_NAME}.${CHECKPOINTS_TABLE_NAME} (
           id TEXT PRIMARY KEY,
           order_key INTEGER NOT NULL,
           unique_key TEXT
         );
-      `);
-      await tx.execute(`
-        CREATE TABLE IF NOT EXISTS ${FILTERS_TABLE_NAME} (
+      `)
+      );
+      await tx.execute(
+        drizzleOrm.sql.raw(`
+        CREATE TABLE IF NOT EXISTS ${constants.SCHEMA_NAME}.${FILTERS_TABLE_NAME} (
           id TEXT NOT NULL,
           filter TEXT NOT NULL,
           from_block INTEGER NOT NULL,
           to_block INTEGER DEFAULT NULL,
           PRIMARY KEY (id, from_block)
         );
-      `);
+      `)
+      );
       await tx.insert(schemaVersion).values({
         k: 0,
         version: CURRENT_SCHEMA_VERSION
@@ -280,10 +292,12 @@ async function resetPersistence(props) {
   }
 }
 
+const ROLLBACK_TABLE_NAME = "reorg_rollback";
+const schema = pgCore.pgSchema(constants.SCHEMA_NAME);
 function getReorgTriggerName(table, indexerId) {
   return `${table}_reorg_${indexerId}`;
 }
-pgCore.pgTable("__reorg_rollback", {
+schema.table(ROLLBACK_TABLE_NAME, {
   n: pgCore.serial("n").primaryKey(),
   op: pgCore.char("op", { length: 1 }).$type().notNull(),
   table_name: pgCore.text("table_name").notNull(),
@@ -294,9 +308,12 @@ pgCore.pgTable("__reorg_rollback", {
 });
 async function initializeReorgRollbackTable(tx, indexerId) {
   try {
+    await tx.execute(`
+    CREATE SCHEMA IF NOT EXISTS ${constants.SCHEMA_NAME};
+    `);
     await tx.execute(
       drizzleOrm.sql.raw(`
-        CREATE TABLE IF NOT EXISTS __reorg_rollback(
+        CREATE TABLE IF NOT EXISTS ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(
           n SERIAL PRIMARY KEY,
           op CHAR(1) NOT NULL,
           table_name TEXT NOT NULL,
@@ -309,7 +326,7 @@ async function initializeReorgRollbackTable(tx, indexerId) {
     );
     await tx.execute(
       drizzleOrm.sql.raw(`
-        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON __reorg_rollback(indexer_id, cursor);
+        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(indexer_id, cursor);
       `)
     );
   } catch (error) {
@@ -320,7 +337,7 @@ async function initializeReorgRollbackTable(tx, indexerId) {
   try {
     await tx.execute(
       drizzleOrm.sql.raw(`
-      CREATE OR REPLACE FUNCTION reorg_checkpoint()
+      CREATE OR REPLACE FUNCTION ${constants.SCHEMA_NAME}.reorg_checkpoint()
       RETURNS TRIGGER AS $$
       DECLARE
         id_col TEXT := TG_ARGV[0]::TEXT;
@@ -330,13 +347,13 @@ async function initializeReorgRollbackTable(tx, indexerId) {
         old_id_value TEXT := row_to_json(OLD.*)->>id_col;
       BEGIN
         IF (TG_OP = 'DELETE') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*), indexer_id;
         ELSIF (TG_OP = 'UPDATE') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*), indexer_id;
         ELSIF (TG_OP = 'INSERT') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null, indexer_id;
         END IF;
         RETURN NULL;
@@ -366,7 +383,7 @@ async function registerTriggers(tx, tables, endCursor, idColumn, indexerId) {
           CREATE CONSTRAINT TRIGGER ${getReorgTriggerName(table, indexerId)}
           AFTER INSERT OR UPDATE OR DELETE ON ${table}
           DEFERRABLE INITIALLY DEFERRED
-          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
+          FOR EACH ROW EXECUTE FUNCTION ${constants.SCHEMA_NAME}.reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
         `)
       );
     }
@@ -395,7 +412,7 @@ async function invalidate(tx, cursor, idColumn, indexerId) {
   const { rows: result } = await tx.execute(
     drizzleOrm.sql.raw(`
       WITH deleted AS (
-        DELETE FROM __reorg_rollback
+        DELETE FROM ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
         WHERE cursor > ${Number(cursor.orderKey)}
         AND indexer_id = '${indexerId}'
         RETURNING *
@@ -488,7 +505,7 @@ async function finalize(tx, cursor, indexerId) {
   try {
     await tx.execute(
       drizzleOrm.sql.raw(`
-      DELETE FROM __reorg_rollback
+      DELETE FROM ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
       WHERE cursor <= ${Number(cursor.orderKey)}
       AND indexer_id = '${indexerId}'
     `)
@@ -510,7 +527,7 @@ async function cleanupStorage(tx, tables, indexerId) {
     }
     await tx.execute(
       drizzleOrm.sql.raw(`
-        DELETE FROM __reorg_rollback
+        DELETE FROM ${constants.SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
         WHERE indexer_id = '${indexerId}'
       `)
     );

package/dist/index.d.cts

@@ -48,7 +48,7 @@ type PgliteDrizzleOptions = {
     type?: "pglite";
     /**
      * Connection string to use for the database
-     * @default "memory://pglite"
+     * @default process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://pglite"
      */
     connectionString?: string;
     /**
@@ -79,6 +79,9 @@ type NodePgDatabase<TSchema extends Record<string, unknown>> = NodePgDatabase$1<
 type Database<TOptions extends DrizzleOptions, TSchema extends Record<string, unknown>> = TOptions extends PgliteDrizzleOptions ? PgliteDatabase<TSchema> : NodePgDatabase<TSchema>;
 /**
  * Creates a new Drizzle database instance based on the provided options
+ *
+ * @important connectionString defaults to process.env["POSTGRES_CONNECTION_STRING"], if not set, it defaults to "memory://" (in-memory pglite)
+ *
  * @param options - Configuration options for the database connection
  * @returns A configured Drizzle database instance
  * @throws {Error} If an invalid database type is specified

package/dist/index.d.mts

@@ -48,7 +48,7 @@ type PgliteDrizzleOptions = {
     type?: "pglite";
     /**
      * Connection string to use for the database
-     * @default "memory://pglite"
+     * @default process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://pglite"
      */
     connectionString?: string;
     /**
@@ -79,6 +79,9 @@ type NodePgDatabase<TSchema extends Record<string, unknown>> = NodePgDatabase$1<
 type Database<TOptions extends DrizzleOptions, TSchema extends Record<string, unknown>> = TOptions extends PgliteDrizzleOptions ? PgliteDatabase<TSchema> : NodePgDatabase<TSchema>;
 /**
  * Creates a new Drizzle database instance based on the provided options
+ *
+ * @important connectionString defaults to process.env["POSTGRES_CONNECTION_STRING"], if not set, it defaults to "memory://" (in-memory pglite)
+ *
  * @param options - Configuration options for the database connection
  * @returns A configured Drizzle database instance
  * @throws {Error} If an invalid database type is specified

package/dist/index.d.ts

@@ -48,7 +48,7 @@ type PgliteDrizzleOptions = {
     type?: "pglite";
     /**
      * Connection string to use for the database
-     * @default "memory://pglite"
+     * @default process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://pglite"
      */
     connectionString?: string;
     /**
@@ -79,6 +79,9 @@ type NodePgDatabase<TSchema extends Record<string, unknown>> = NodePgDatabase$1<
 type Database<TOptions extends DrizzleOptions, TSchema extends Record<string, unknown>> = TOptions extends PgliteDrizzleOptions ? PgliteDatabase<TSchema> : NodePgDatabase<TSchema>;
 /**
  * Creates a new Drizzle database instance based on the provided options
+ *
+ * @important connectionString defaults to process.env["POSTGRES_CONNECTION_STRING"], if not set, it defaults to "memory://" (in-memory pglite)
+ *
  * @param options - Configuration options for the database connection
  * @returns A configured Drizzle database instance
  * @throws {Error} If an invalid database type is specified

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { useIndexerContext } from '@apibara/indexer';
 import { defineIndexerPlugin, useLogger } from '@apibara/indexer/plugins';
 import { generateIndexerId } from '@apibara/indexer/internal';
 import { useInternalContext } from '@apibara/indexer/internal/plugins';
-import { D as DRIZZLE_PROPERTY, a as DRIZZLE_STORAGE_DB_PROPERTY } from './shared/plugin-drizzle.f8d1b186.mjs';
+import { S as SCHEMA_NAME, D as DRIZZLE_PROPERTY, a as DRIZZLE_STORAGE_DB_PROPERTY } from './shared/plugin-drizzle.2d226351.mjs';
 import { PGlite } from '@electric-sql/pglite';
 import { drizzle as drizzle$1 } from 'drizzle-orm/node-postgres';
 import { migrate as migrate$2 } from 'drizzle-orm/node-postgres/migrator';
@@ -10,8 +10,8 @@ import { drizzle as drizzle$2 } from 'drizzle-orm/pglite';
 import { migrate as migrate$1 } from 'drizzle-orm/pglite/migrator';
 import pg from 'pg';
 import { normalizeCursor } from '@apibara/protocol';
-import { eq, and, isNull, gt, lt, sql } from 'drizzle-orm';
-import { pgTable, text, integer, primaryKey, serial, char, jsonb } from 'drizzle-orm/pg-core';
+import { sql, eq, and, isNull, gt, lt } from 'drizzle-orm';
+import { pgSchema, text, integer, primaryKey, serial, char, jsonb } from 'drizzle-orm/pg-core';
 
 class DrizzleStorageError extends Error {
   constructor(message, options) {
@@ -43,7 +43,7 @@ function sleep(ms) {
 
 function drizzle(options) {
   const {
-    connectionString = "memory://",
+    connectionString = process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://",
     schema,
     type = "pglite",
     config,
@@ -85,15 +85,16 @@ async function migrate(db, options) {
   }
 }
 
-const CHECKPOINTS_TABLE_NAME = "__indexer_checkpoints";
-const FILTERS_TABLE_NAME = "__indexer_filters";
-const SCHEMA_VERSION_TABLE_NAME = "__indexer_schema_version";
-const checkpoints = pgTable(CHECKPOINTS_TABLE_NAME, {
+const CHECKPOINTS_TABLE_NAME = "checkpoints";
+const FILTERS_TABLE_NAME = "filters";
+const SCHEMA_VERSION_TABLE_NAME = "schema_version";
+const schema$1 = pgSchema(SCHEMA_NAME);
+const checkpoints = schema$1.table(CHECKPOINTS_TABLE_NAME, {
   id: text("id").notNull().primaryKey(),
   orderKey: integer("order_key").notNull(),
   uniqueKey: text("unique_key")
 });
-const filters = pgTable(
+const filters = schema$1.table(
   FILTERS_TABLE_NAME,
   {
     id: text("id").notNull(),
@@ -107,7 +108,7 @@ const filters = pgTable(
     }
   ]
 );
-const schemaVersion = pgTable(SCHEMA_VERSION_TABLE_NAME, {
+const schemaVersion = schema$1.table(SCHEMA_VERSION_TABLE_NAME, {
   k: integer("k").notNull().primaryKey(),
   version: integer("version").notNull()
 });
@@ -118,12 +119,19 @@ const MIGRATIONS = [
   // Add more migration arrays for future versions
 ];
 async function initializePersistentState(tx) {
-  await tx.execute(`
-    CREATE TABLE IF NOT EXISTS ${SCHEMA_VERSION_TABLE_NAME} (
+  await tx.execute(
+    sql.raw(`
+      CREATE SCHEMA IF NOT EXISTS ${SCHEMA_NAME};
+  `)
+  );
+  await tx.execute(
+    sql.raw(`
+    CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${SCHEMA_VERSION_TABLE_NAME} (
       k INTEGER PRIMARY KEY,
       version INTEGER NOT NULL
     );
-  `);
+  `)
+  );
   const versionRows = await tx.select().from(schemaVersion).where(eq(schemaVersion.k, 0));
   const storedVersion = versionRows[0]?.version ?? -1;
   if (storedVersion > CURRENT_SCHEMA_VERSION) {
@@ -133,22 +141,26 @@ async function initializePersistentState(tx) {
   }
   try {
     if (storedVersion === -1) {
-      await tx.execute(`
-        CREATE TABLE IF NOT EXISTS ${CHECKPOINTS_TABLE_NAME} (
+      await tx.execute(
+        sql.raw(`
+        CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${CHECKPOINTS_TABLE_NAME} (
           id TEXT PRIMARY KEY,
           order_key INTEGER NOT NULL,
           unique_key TEXT
         );
-      `);
-      await tx.execute(`
-        CREATE TABLE IF NOT EXISTS ${FILTERS_TABLE_NAME} (
+      `)
+      );
+      await tx.execute(
+        sql.raw(`
+        CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${FILTERS_TABLE_NAME} (
           id TEXT NOT NULL,
           filter TEXT NOT NULL,
           from_block INTEGER NOT NULL,
           to_block INTEGER DEFAULT NULL,
           PRIMARY KEY (id, from_block)
         );
-      `);
+      `)
+      );
       await tx.insert(schemaVersion).values({
         k: 0,
         version: CURRENT_SCHEMA_VERSION
@@ -274,10 +286,12 @@ async function resetPersistence(props) {
   }
 }
 
+const ROLLBACK_TABLE_NAME = "reorg_rollback";
+const schema = pgSchema(SCHEMA_NAME);
 function getReorgTriggerName(table, indexerId) {
   return `${table}_reorg_${indexerId}`;
 }
-pgTable("__reorg_rollback", {
+schema.table(ROLLBACK_TABLE_NAME, {
   n: serial("n").primaryKey(),
   op: char("op", { length: 1 }).$type().notNull(),
   table_name: text("table_name").notNull(),
@@ -288,9 +302,12 @@ pgTable("__reorg_rollback", {
 });
 async function initializeReorgRollbackTable(tx, indexerId) {
   try {
+    await tx.execute(`
+    CREATE SCHEMA IF NOT EXISTS ${SCHEMA_NAME};
+    `);
     await tx.execute(
       sql.raw(`
-        CREATE TABLE IF NOT EXISTS __reorg_rollback(
+        CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(
           n SERIAL PRIMARY KEY,
           op CHAR(1) NOT NULL,
           table_name TEXT NOT NULL,
@@ -303,7 +320,7 @@ async function initializeReorgRollbackTable(tx, indexerId) {
     );
     await tx.execute(
       sql.raw(`
-        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON __reorg_rollback(indexer_id, cursor);
+        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(indexer_id, cursor);
       `)
     );
   } catch (error) {
@@ -314,7 +331,7 @@ async function initializeReorgRollbackTable(tx, indexerId) {
   try {
     await tx.execute(
       sql.raw(`
-      CREATE OR REPLACE FUNCTION reorg_checkpoint()
+      CREATE OR REPLACE FUNCTION ${SCHEMA_NAME}.reorg_checkpoint()
       RETURNS TRIGGER AS $$
       DECLARE
         id_col TEXT := TG_ARGV[0]::TEXT;
@@ -324,13 +341,13 @@ async function initializeReorgRollbackTable(tx, indexerId) {
         old_id_value TEXT := row_to_json(OLD.*)->>id_col;
       BEGIN
         IF (TG_OP = 'DELETE') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*), indexer_id;
         ELSIF (TG_OP = 'UPDATE') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*), indexer_id;
         ELSIF (TG_OP = 'INSERT') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null, indexer_id;
         END IF;
         RETURN NULL;
@@ -360,7 +377,7 @@ async function registerTriggers(tx, tables, endCursor, idColumn, indexerId) {
           CREATE CONSTRAINT TRIGGER ${getReorgTriggerName(table, indexerId)}
           AFTER INSERT OR UPDATE OR DELETE ON ${table}
           DEFERRABLE INITIALLY DEFERRED
-          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
+          FOR EACH ROW EXECUTE FUNCTION ${SCHEMA_NAME}.reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
         `)
       );
     }
@@ -389,7 +406,7 @@ async function invalidate(tx, cursor, idColumn, indexerId) {
   const { rows: result } = await tx.execute(
     sql.raw(`
       WITH deleted AS (
-        DELETE FROM __reorg_rollback
+        DELETE FROM ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
         WHERE cursor > ${Number(cursor.orderKey)}
         AND indexer_id = '${indexerId}'
         RETURNING *
@@ -482,7 +499,7 @@ async function finalize(tx, cursor, indexerId) {
   try {
     await tx.execute(
       sql.raw(`
-      DELETE FROM __reorg_rollback
+      DELETE FROM ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
       WHERE cursor <= ${Number(cursor.orderKey)}
       AND indexer_id = '${indexerId}'
     `)
@@ -504,7 +521,7 @@ async function cleanupStorage(tx, tables, indexerId) {
     }
     await tx.execute(
       sql.raw(`
-        DELETE FROM __reorg_rollback
+        DELETE FROM ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
         WHERE indexer_id = '${indexerId}'
       `)
     );

package/dist/shared/plugin-drizzle.2d226351.mjs

@@ -0,0 +1,5 @@
+const DRIZZLE_PROPERTY = "_drizzle";
+const DRIZZLE_STORAGE_DB_PROPERTY = "_drizzleStorageDB";
+const SCHEMA_NAME = "airfoil";
+
+export { DRIZZLE_PROPERTY as D, SCHEMA_NAME as S, DRIZZLE_STORAGE_DB_PROPERTY as a };

package/dist/shared/{plugin-drizzle.e884ca32.cjs → plugin-drizzle.cae20704.cjs}

@@ -2,6 +2,8 @@
 
 const DRIZZLE_PROPERTY = "_drizzle";
 const DRIZZLE_STORAGE_DB_PROPERTY = "_drizzleStorageDB";
+const SCHEMA_NAME = "airfoil";
 
 exports.DRIZZLE_PROPERTY = DRIZZLE_PROPERTY;
 exports.DRIZZLE_STORAGE_DB_PROPERTY = DRIZZLE_STORAGE_DB_PROPERTY;
+exports.SCHEMA_NAME = SCHEMA_NAME;

package/dist/testing.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const constants = require('./shared/plugin-drizzle.e884ca32.cjs');
+const constants = require('./shared/plugin-drizzle.cae20704.cjs');
 
 function getTestDatabase(context) {
   const db = context[constants.DRIZZLE_STORAGE_DB_PROPERTY];

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { a as DRIZZLE_STORAGE_DB_PROPERTY } from './shared/plugin-drizzle.f8d1b186.mjs';
+import { a as DRIZZLE_STORAGE_DB_PROPERTY } from './shared/plugin-drizzle.2d226351.mjs';
 
 function getTestDatabase(context) {
   const db = context[DRIZZLE_STORAGE_DB_PROPERTY];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/plugin-drizzle",
-  "version": "2.1.0-beta.14",
+  "version": "2.1.0-beta.16",
   "type": "module",
   "files": [
     "dist",
@@ -45,8 +45,8 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/indexer": "2.1.0-beta.14",
-    "@apibara/protocol": "2.1.0-beta.14",
+    "@apibara/indexer": "2.1.0-beta.16",
+    "@apibara/protocol": "2.1.0-beta.16",
     "postgres-range": "^1.1.4"
   }
 }

package/src/constants.ts

@@ -1,2 +1,3 @@
 export const DRIZZLE_PROPERTY = "_drizzle";
 export const DRIZZLE_STORAGE_DB_PROPERTY = "_drizzleStorageDB";
+export const SCHEMA_NAME = "airfoil";

package/src/helper.ts

@@ -58,7 +58,7 @@ export type PgliteDrizzleOptions = {
   type?: "pglite";
   /**
    * Connection string to use for the database
-   * @default "memory://pglite"
+   * @default process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://pglite"
    */
   connectionString?: string;
   /**
@@ -102,6 +102,9 @@ export type Database<
 
 /**
  * Creates a new Drizzle database instance based on the provided options
+ *
+ * @important connectionString defaults to process.env["POSTGRES_CONNECTION_STRING"], if not set, it defaults to "memory://" (in-memory pglite)
+ *
  * @param options - Configuration options for the database connection
  * @returns A configured Drizzle database instance
  * @throws {Error} If an invalid database type is specified
@@ -119,7 +122,7 @@ export function drizzle<
   },
 ): Database<TOptions, TSchema> {
   const {
-    connectionString = "memory://",
+    connectionString = process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://",
     schema,
     type = "pglite",
     config,

package/src/persistence.ts

@@ -1,24 +1,29 @@
 import { type Cursor, normalizeCursor } from "@apibara/protocol";
-import { and, eq, gt, isNull, lt } from "drizzle-orm";
+import { and, eq, gt, isNull, lt, sql } from "drizzle-orm";
 import type {
   ExtractTablesWithRelations,
   TablesRelationalConfig,
 } from "drizzle-orm";
 import type { PgQueryResultHKT, PgTransaction } from "drizzle-orm/pg-core";
-import { integer, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
+import { integer, pgSchema, primaryKey, text } from "drizzle-orm/pg-core";
+import { SCHEMA_NAME } from "./constants";
 import { DrizzleStorageError, deserialize, serialize } from "./utils";
 
-const CHECKPOINTS_TABLE_NAME = "__indexer_checkpoints";
-const FILTERS_TABLE_NAME = "__indexer_filters";
-const SCHEMA_VERSION_TABLE_NAME = "__indexer_schema_version";
+const CHECKPOINTS_TABLE_NAME = "checkpoints";
+const FILTERS_TABLE_NAME = "filters";
+const SCHEMA_VERSION_TABLE_NAME = "schema_version";
 
-export const checkpoints = pgTable(CHECKPOINTS_TABLE_NAME, {
+const schema = pgSchema(SCHEMA_NAME);
+
+/** This table is not used for migrations, its only used for ease of internal operations with drizzle. */
+export const checkpoints = schema.table(CHECKPOINTS_TABLE_NAME, {
   id: text("id").notNull().primaryKey(),
   orderKey: integer("order_key").notNull(),
   uniqueKey: text("unique_key"),
 });
 
-export const filters = pgTable(
+/** This table is not used for migrations, its only used for ease of internal operations with drizzle. */
+export const filters = schema.table(
   FILTERS_TABLE_NAME,
   {
     id: text("id").notNull(),
@@ -33,7 +38,8 @@ export const filters = pgTable(
   ],
 );
 
-export const schemaVersion = pgTable(SCHEMA_VERSION_TABLE_NAME, {
+/** This table is not used for migrations, its only used for ease of internal operations with drizzle. */
+export const schemaVersion = schema.table(SCHEMA_VERSION_TABLE_NAME, {
   k: integer("k").notNull().primaryKey(),
   version: integer("version").notNull(),
 });
@@ -53,13 +59,22 @@ export async function initializePersistentState<
   TSchema extends
     TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
 >(tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) {
+  // Create schema if it doesn't exist
+  await tx.execute(
+    sql.raw(`
+      CREATE SCHEMA IF NOT EXISTS ${SCHEMA_NAME};
+  `),
+  );
+
   // Create schema version table
-  await tx.execute(`
-    CREATE TABLE IF NOT EXISTS ${SCHEMA_VERSION_TABLE_NAME} (
+  await tx.execute(
+    sql.raw(`
+    CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${SCHEMA_VERSION_TABLE_NAME} (
       k INTEGER PRIMARY KEY,
       version INTEGER NOT NULL
     );
-  `);
+  `),
+  );
 
   // Get current schema version
   const versionRows = await tx
@@ -80,23 +95,27 @@ export async function initializePersistentState<
   try {
     if (storedVersion === -1) {
       // First time initialization
-      await tx.execute(`
-        CREATE TABLE IF NOT EXISTS ${CHECKPOINTS_TABLE_NAME} (
+      await tx.execute(
+        sql.raw(`
+        CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${CHECKPOINTS_TABLE_NAME} (
           id TEXT PRIMARY KEY,
           order_key INTEGER NOT NULL,
           unique_key TEXT
         );
-      `);
+      `),
+      );
 
-      await tx.execute(`
-        CREATE TABLE IF NOT EXISTS ${FILTERS_TABLE_NAME} (
+      await tx.execute(
+        sql.raw(`
+        CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${FILTERS_TABLE_NAME} (
           id TEXT NOT NULL,
           filter TEXT NOT NULL,
           from_block INTEGER NOT NULL,
           to_block INTEGER DEFAULT NULL,
           PRIMARY KEY (id, from_block)
         );
-      `);
+      `),
+      );
 
       // Set initial schema version
       await tx.insert(schemaVersion).values({

package/src/storage.ts

@@ -11,19 +11,25 @@ import {
   char,
   integer,
   jsonb,
-  pgTable,
+  pgSchema,
   serial,
   text,
 } from "drizzle-orm/pg-core";
+import { SCHEMA_NAME } from "./constants";
 import { DrizzleStorageError } from "./utils";
 
+const ROLLBACK_TABLE_NAME = "reorg_rollback";
+
+const schema = pgSchema(SCHEMA_NAME);
+
 function getReorgTriggerName(table: string, indexerId: string) {
   return `${table}_reorg_${indexerId}`;
 }
 
 export type ReorgOperation = "I" | "U" | "D";
 
-export const reorgRollbackTable = pgTable("__reorg_rollback", {
+/** This table is not used for migrations, its only used for ease of internal operations with drizzle. */
+export const reorgRollbackTable = schema.table(ROLLBACK_TABLE_NAME, {
   n: serial("n").primaryKey(),
   op: char("op", { length: 1 }).$type<ReorgOperation>().notNull(),
   table_name: text("table_name").notNull(),
@@ -42,10 +48,14 @@ export async function initializeReorgRollbackTable<
     TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
 >(tx: PgTransaction<TQueryResult, TFullSchema, TSchema>, indexerId: string) {
   try {
+    // Create schema if it doesn't exist
+    await tx.execute(`
+    CREATE SCHEMA IF NOT EXISTS ${SCHEMA_NAME};
+    `);
     // Create the audit log table
     await tx.execute(
       sql.raw(`
-        CREATE TABLE IF NOT EXISTS __reorg_rollback(
+        CREATE TABLE IF NOT EXISTS ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(
           n SERIAL PRIMARY KEY,
           op CHAR(1) NOT NULL,
           table_name TEXT NOT NULL,
@@ -59,7 +69,7 @@ export async function initializeReorgRollbackTable<
 
     await tx.execute(
       sql.raw(`
-        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON __reorg_rollback(indexer_id, cursor);
+        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(indexer_id, cursor);
       `),
     );
   } catch (error) {
@@ -72,7 +82,7 @@ export async function initializeReorgRollbackTable<
     // Create the trigger function
     await tx.execute(
       sql.raw(`
-      CREATE OR REPLACE FUNCTION reorg_checkpoint()
+      CREATE OR REPLACE FUNCTION ${SCHEMA_NAME}.reorg_checkpoint()
       RETURNS TRIGGER AS $$
       DECLARE
         id_col TEXT := TG_ARGV[0]::TEXT;
@@ -82,13 +92,13 @@ export async function initializeReorgRollbackTable<
         old_id_value TEXT := row_to_json(OLD.*)->>id_col;
       BEGIN
         IF (TG_OP = 'DELETE') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*), indexer_id;
         ELSIF (TG_OP = 'UPDATE') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*), indexer_id;
         ELSIF (TG_OP = 'INSERT') THEN
-          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+          INSERT INTO ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}(op, table_name, cursor, row_id, row_value, indexer_id)
             SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null, indexer_id;
         END IF;
         RETURN NULL;
@@ -130,7 +140,7 @@ export async function registerTriggers<
           CREATE CONSTRAINT TRIGGER ${getReorgTriggerName(table, indexerId)}
           AFTER INSERT OR UPDATE OR DELETE ON ${table}
           DEFERRABLE INITIALLY DEFERRED
-          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
+          FOR EACH ROW EXECUTE FUNCTION ${SCHEMA_NAME}.reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
         `),
       );
     }
@@ -181,7 +191,7 @@ export async function invalidate<
   const { rows: result } = (await tx.execute(
     sql.raw(`
       WITH deleted AS (
-        DELETE FROM __reorg_rollback
+        DELETE FROM ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
         WHERE cursor > ${Number(cursor.orderKey)}
         AND indexer_id = '${indexerId}'
         RETURNING *
@@ -305,7 +315,7 @@ export async function finalize<
   try {
     await tx.execute(
       sql.raw(`
-      DELETE FROM __reorg_rollback
+      DELETE FROM ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
       WHERE cursor <= ${Number(cursor.orderKey)}
       AND indexer_id = '${indexerId}'
     `),
@@ -338,7 +348,7 @@ export async function cleanupStorage<
 
     await tx.execute(
       sql.raw(`
-        DELETE FROM __reorg_rollback
+        DELETE FROM ${SCHEMA_NAME}.${ROLLBACK_TABLE_NAME}
         WHERE indexer_id = '${indexerId}'
       `),
     );

package/dist/shared/plugin-drizzle.f8d1b186.mjs

@@ -1,4 +0,0 @@
-const DRIZZLE_PROPERTY = "_drizzle";
-const DRIZZLE_STORAGE_DB_PROPERTY = "_drizzleStorageDB";
-
-export { DRIZZLE_PROPERTY as D, DRIZZLE_STORAGE_DB_PROPERTY as a };