@apibara/plugin-drizzle 2.1.0-beta.21 → 2.1.0-beta.23

package/dist/index.cjs

@@ -5,20 +5,10 @@ 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.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');
-const pglite = require('drizzle-orm/pglite');
-const migrator = require('drizzle-orm/pglite/migrator');
-const pg = require('pg');
-const protocol = require('@apibara/protocol');
 const drizzleOrm = require('drizzle-orm');
+const protocol = require('@apibara/protocol');
 const pgCore = require('drizzle-orm/pg-core');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const pg__default = /*#__PURE__*/_interopDefaultCompat(pg);
-
 class DrizzleStorageError extends Error {
   constructor(message, options) {
     super(message, options);
@@ -61,15 +51,9 @@ function drizzle(options) {
     config,
     poolConfig
   } = options ?? {};
-  if (isPostgresConnectionString(connectionString) || type === "node-postgres") {
-    const pool = new pg__default.Pool({
-      connectionString,
-      ...poolConfig || {}
-    });
-    return nodePostgres.drizzle(pool, { schema, ...config || {} });
-  }
-  if (type === "pglite") {
-    return pglite.drizzle({
+  if (isPgliteConnectionString(connectionString) && type === "pglite") {
+    const { drizzle: drizzlePGLite } = require("drizzle-orm/pglite");
+    return drizzlePGLite({
       schema,
       connection: {
         dataDir: connectionString || "memory://pglite"
@@ -77,15 +61,25 @@ function drizzle(options) {
       ...config || {}
     });
   }
-  throw new Error("Invalid database type");
+  const { Pool } = require("pg");
+  const { drizzle: drizzleNode } = require("drizzle-orm/node-postgres");
+  const pool = new Pool({
+    connectionString,
+    ...poolConfig || {}
+  });
+  return drizzleNode(pool, { schema, ...config || {} });
 }
 async function migrate(db, options) {
-  const isPglite = !!("$client" in db && db.$client instanceof pglite$1.PGlite);
+  const isPglite = isDrizzleKind(db, "PgliteDatabase");
   try {
     if (isPglite) {
-      await migrator.migrate(db, options);
+      const { migrate: migratePGLite } = require("drizzle-orm/pglite/migrator");
+      await migratePGLite(db, options);
     } else {
-      await migrator$1.migrate(db, options);
+      const {
+        migrate: migrateNode
+      } = require("drizzle-orm/node-postgres/migrator");
+      await migrateNode(db, options);
     }
   } catch (error) {
     throw new DrizzleStorageError(
@@ -96,8 +90,23 @@ async function migrate(db, options) {
     );
   }
 }
-function isPostgresConnectionString(conn) {
-  return conn.startsWith("postgres://") || conn.startsWith("postgresql://");
+function isPgliteConnectionString(conn) {
+  return conn.startsWith("memory://") || conn.startsWith("file://") || conn.startsWith("idb://");
+}
+function isDrizzleKind(value, entityKindValue) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (drizzleOrm.entityKind in cls && cls[drizzleOrm.entityKind] === entityKindValue) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
 }
 
 const CHECKPOINTS_TABLE_NAME = "checkpoints";

package/dist/index.mjs

@@ -3,14 +3,8 @@ import { defineIndexerPlugin, useLogger } from '@apibara/indexer/plugins';
 import { generateIndexerId } from '@apibara/indexer/internal';
 import { useInternalContext } from '@apibara/indexer/internal/plugins';
 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';
-import { drizzle as drizzle$2 } from 'drizzle-orm/pglite';
-import { migrate as migrate$1 } from 'drizzle-orm/pglite/migrator';
-import pg from 'pg';
+import { entityKind, sql, eq, and, isNull, gt, lt } from 'drizzle-orm';
 import { normalizeCursor } from '@apibara/protocol';
-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 {
@@ -55,15 +49,9 @@ function drizzle(options) {
     config,
     poolConfig
   } = options ?? {};
-  if (isPostgresConnectionString(connectionString) || type === "node-postgres") {
-    const pool = new pg.Pool({
-      connectionString,
-      ...poolConfig || {}
-    });
-    return drizzle$1(pool, { schema, ...config || {} });
-  }
-  if (type === "pglite") {
-    return drizzle$2({
+  if (isPgliteConnectionString(connectionString) && type === "pglite") {
+    const { drizzle: drizzlePGLite } = require("drizzle-orm/pglite");
+    return drizzlePGLite({
       schema,
       connection: {
         dataDir: connectionString || "memory://pglite"
@@ -71,15 +59,25 @@ function drizzle(options) {
       ...config || {}
     });
   }
-  throw new Error("Invalid database type");
+  const { Pool } = require("pg");
+  const { drizzle: drizzleNode } = require("drizzle-orm/node-postgres");
+  const pool = new Pool({
+    connectionString,
+    ...poolConfig || {}
+  });
+  return drizzleNode(pool, { schema, ...config || {} });
 }
 async function migrate(db, options) {
-  const isPglite = !!("$client" in db && db.$client instanceof PGlite);
+  const isPglite = isDrizzleKind(db, "PgliteDatabase");
   try {
     if (isPglite) {
-      await migrate$1(db, options);
+      const { migrate: migratePGLite } = require("drizzle-orm/pglite/migrator");
+      await migratePGLite(db, options);
     } else {
-      await migrate$2(db, options);
+      const {
+        migrate: migrateNode
+      } = require("drizzle-orm/node-postgres/migrator");
+      await migrateNode(db, options);
     }
   } catch (error) {
     throw new DrizzleStorageError(
@@ -90,8 +88,23 @@ async function migrate(db, options) {
     );
   }
 }
-function isPostgresConnectionString(conn) {
-  return conn.startsWith("postgres://") || conn.startsWith("postgresql://");
+function isPgliteConnectionString(conn) {
+  return conn.startsWith("memory://") || conn.startsWith("file://") || conn.startsWith("idb://");
+}
+function isDrizzleKind(value, entityKindValue) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === entityKindValue) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
 }
 
 const CHECKPOINTS_TABLE_NAME = "checkpoints";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/plugin-drizzle",
-  "version": "2.1.0-beta.21",
+  "version": "2.1.0-beta.23",
   "type": "module",
   "files": [
     "dist",
@@ -32,9 +32,18 @@
     "test:ci": "vitest run"
   },
   "peerDependencies": {
+    "@electric-sql/pglite": ">=0.2.0",
     "drizzle-orm": "<1",
     "pg": ">=8"
   },
+  "peerDependenciesMeta": {
+    "@electric-sql/pglite": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@electric-sql/pglite": "^0.2.17",
     "@types/node": "^20.14.0",
@@ -45,8 +54,8 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/indexer": "2.1.0-beta.21",
-    "@apibara/protocol": "2.1.0-beta.21",
+    "@apibara/indexer": "2.1.0-beta.23",
+    "@apibara/protocol": "2.1.0-beta.23",
     "postgres-range": "^1.1.4"
   }
 }

package/src/helper.ts

@@ -1,18 +1,10 @@
-import { PGlite, type PGliteOptions } from "@electric-sql/pglite";
+import type { PGlite, PGliteOptions } from "@electric-sql/pglite";
 import type { DrizzleConfig } from "drizzle-orm";
+import { entityKind } from "drizzle-orm";
 import type { MigrationConfig } from "drizzle-orm/migrator";
-import {
-  type NodePgDatabase as OriginalNodePgDatabase,
-  drizzle as drizzleNode,
-} from "drizzle-orm/node-postgres";
-import { migrate as migrateNode } from "drizzle-orm/node-postgres/migrator";
-import {} from "drizzle-orm/pg-core";
-import {
-  type PgliteDatabase as OriginalPgliteDatabase,
-  drizzle as drizzlePGLite,
-} from "drizzle-orm/pglite";
-import { migrate as migratePGLite } from "drizzle-orm/pglite/migrator";
-import pg from "pg";
+import type { NodePgDatabase as OriginalNodePgDatabase } from "drizzle-orm/node-postgres";
+import type { PgliteDatabase as OriginalPgliteDatabase } from "drizzle-orm/pglite";
+import type pg from "pg";
 import { DrizzleStorageError } from "./utils";
 
 /**
@@ -129,21 +121,9 @@ export function drizzle<
     poolConfig,
   } = options ?? {};
 
-  if (
-    isPostgresConnectionString(connectionString) ||
-    type === "node-postgres"
-  ) {
-    const pool = new pg.Pool({
-      connectionString,
-      ...(poolConfig || {}),
-    });
-    return drizzleNode(pool, { schema, ...(config || {}) }) as Database<
-      TOptions,
-      TSchema
-    >;
-  }
+  if (isPgliteConnectionString(connectionString) && type === "pglite") {
+    const { drizzle: drizzlePGLite } = require("drizzle-orm/pglite");
 
-  if (type === "pglite") {
     return drizzlePGLite({
       schema: schema as TSchema,
       connection: {
@@ -153,7 +133,16 @@ export function drizzle<
     }) as Database<TOptions, TSchema>;
   }
 
-  throw new Error("Invalid database type");
+  const { Pool } = require("pg");
+  const { drizzle: drizzleNode } = require("drizzle-orm/node-postgres");
+  const pool = new Pool({
+    connectionString,
+    ...(poolConfig || {}),
+  });
+  return drizzleNode(pool, { schema, ...(config || {}) }) as Database<
+    TOptions,
+    TSchema
+  >;
 }
 
 /**
@@ -179,12 +168,16 @@ export async function migrate<TSchema extends Record<string, unknown>>(
   db: PgliteDatabase<TSchema> | NodePgDatabase<TSchema>,
   options: MigrateOptions,
 ) {
-  const isPglite = !!("$client" in db && db.$client instanceof PGlite);
+  const isPglite = isDrizzleKind(db, "PgliteDatabase");
 
   try {
     if (isPglite) {
+      const { migrate: migratePGLite } = require("drizzle-orm/pglite/migrator");
       await migratePGLite(db as PgliteDatabase<TSchema>, options);
     } else {
+      const {
+        migrate: migrateNode,
+      } = require("drizzle-orm/node-postgres/migrator");
       await migrateNode(db as NodePgDatabase<TSchema>, options);
     }
   } catch (error) {
@@ -197,6 +190,30 @@ export async function migrate<TSchema extends Record<string, unknown>>(
   }
 }
 
-function isPostgresConnectionString(conn: string) {
-  return conn.startsWith("postgres://") || conn.startsWith("postgresql://");
+function isPgliteConnectionString(conn: string) {
+  return (
+    conn.startsWith("memory://") ||
+    conn.startsWith("file://") ||
+    conn.startsWith("idb://")
+  );
+}
+
+function isDrizzleKind(value: unknown, entityKindValue: string) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  // https://github.com/drizzle-team/drizzle-orm/blob/f39f885779800982e90dd3c89aba6df3217a6fd2/drizzle-orm/src/entity.ts#L29-L41
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    // Traverse the prototype chain to find the entityKind
+    while (cls) {
+      // https://github.com/drizzle-team/drizzle-orm/blob/f39f885779800982e90dd3c89aba6df3217a6fd2/drizzle-orm/src/pglite/driver.ts#L41
+      if (entityKind in cls && cls[entityKind] === entityKindValue) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+
+  return false;
 }