prisma-flare 1.0.0 → 1.1.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/core/extendedPrismaClient.ts
-import { PrismaClient } from "@prisma/client";
+import { PrismaClient as PrismaClient2 } from "@prisma/client";
 
 // src/core/modelRegistry.ts
 var ModelRegistry = class {
@@ -657,53 +657,6 @@ var FlareBuilder = class _FlareBuilder {
   }
 };
 
-// src/core/extendedPrismaClient.ts
-var FlareClient = class extends PrismaClient {
-  constructor(options = {}) {
-    super(options);
-  }
-  /**
-   * Creates a new FlareBuilder instance for the specified model.
-   * @param modelName - The name of the model.
-   * @returns FlareBuilder instance
-   */
-  from(modelName) {
-    const key = modelName.charAt(0).toLowerCase() + modelName.slice(1);
-    const model = this[key];
-    if (!model) {
-      throw new Error(`Model ${modelName} does not exist on PrismaClient.`);
-    }
-    return new FlareBuilder(model);
-  }
-  /**
-   * Executes a transaction with the FlareClient capabilities.
-   * @param fn - The transaction function.
-   * @param options - Transaction options.
-   * @returns The result of the transaction.
-   */
-  async transaction(fn, options) {
-    return super.$transaction(async (tx) => {
-      const extendedTx = new Proxy(tx, {
-        get: (target, prop, receiver) => {
-          if (prop === "from") {
-            return (modelName) => {
-              const key = modelName.charAt(0).toLowerCase() + modelName.slice(1);
-              const model = target[key];
-              if (!model) {
-                throw new Error(`Model ${modelName} does not exist on TransactionClient.`);
-              }
-              return new FlareBuilder(model);
-            };
-          }
-          return Reflect.get(target, prop, receiver);
-        }
-      });
-      return fn(extendedTx);
-    }, options);
-  }
-};
-var ExtendedPrismaClient = FlareClient;
-
 // src/core/hookRegistry.ts
 function valuesEqual(a, b) {
   if (a == null && b == null) return true;
@@ -875,76 +828,10 @@ var HookRegistry = class {
 var hookRegistry = new HookRegistry();
 var hookRegistry_default = hookRegistry;
 
-// src/core/hooks.ts
-function normalizeModelName(model) {
-  return model.toLowerCase();
-}
-function beforeCreate(model, callback) {
-  hookRegistry_default.addHook(normalizeModelName(model), "create", "before", callback);
-}
-function beforeDelete(model, callback) {
-  hookRegistry_default.addHook(normalizeModelName(model), "delete", "before", callback);
-}
-function afterCreate(model, callback) {
-  hookRegistry_default.addHook(normalizeModelName(model), "create", "after", callback);
-}
-function afterDelete(model, callback) {
-  hookRegistry_default.addHook(normalizeModelName(model), "delete", "after", callback);
-}
-function beforeUpdate(model, callback) {
-  hookRegistry_default.addHook(normalizeModelName(model), "update", "before", callback);
-}
-function afterUpdate(model, callback) {
-  hookRegistry_default.addHook(normalizeModelName(model), "update", "after", callback);
-}
-function afterChange(model, column, callback) {
-  hookRegistry_default.addColumnHook(normalizeModelName(model), column, callback);
-}
-function afterUpsert(model, callback) {
-  hookRegistry_default.addHook(normalizeModelName(model), "upsert", "after", callback);
-}
-
 // src/core/hookMiddleware.ts
 import { Prisma } from "@prisma/client";
-
-// src/cli/config.ts
-import * as fs from "fs";
-import * as path from "path";
-function findProjectRoot(currentDir) {
-  if (fs.existsSync(path.join(currentDir, "package.json"))) {
-    return currentDir;
-  }
-  const parentDir = path.dirname(currentDir);
-  if (parentDir === currentDir) {
-    throw new Error("Could not find package.json");
-  }
-  return findProjectRoot(parentDir);
-}
-function loadConfig(rootDir) {
-  const projectRoot = rootDir || findProjectRoot(process.cwd());
-  const configPath = path.join(projectRoot, "prisma-flare.config.json");
-  let config = {
-    modelsPath: "prisma/models",
-    dbPath: "prisma/db",
-    callbacksPath: "prisma/callbacks"
-  };
-  if (fs.existsSync(configPath)) {
-    try {
-      const configFile = fs.readFileSync(configPath, "utf-8");
-      const userConfig = JSON.parse(configFile);
-      config = { ...config, ...userConfig };
-    } catch {
-      console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
-    }
-  }
-  return {
-    ...config
-  };
-}
-
-// src/core/hookMiddleware.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path from "path";
 function supportsTypeScriptImports() {
   if (process.env.TS_NODE || /* @__PURE__ */ Symbol.for("ts-node.register.instance") in process) {
     return true;
@@ -962,16 +849,16 @@ function supportsTypeScriptImports() {
 }
 async function loadCallbacks(callbacksDir) {
   if (!callbacksDir) {
-    callbacksDir = path2.join(process.cwd(), "prisma", "callbacks");
+    callbacksDir = path.join(process.cwd(), "prisma", "callbacks");
   }
-  if (!fs2.existsSync(callbacksDir)) {
+  if (!fs.existsSync(callbacksDir)) {
     console.warn(`Callbacks directory not found: ${callbacksDir}`);
     return;
   }
   const canImportTs = supportsTypeScriptImports();
-  const files = fs2.readdirSync(callbacksDir);
+  const files = fs.readdirSync(callbacksDir);
   for (const file of files) {
-    const filePath = path2.join(callbacksDir, file);
+    const filePath = path.join(callbacksDir, file);
     if (file.endsWith(".js")) {
       await import(filePath);
     } else if (file.endsWith(".ts") && canImportTs) {
@@ -1013,7 +900,7 @@ async function executeHookLogic(prisma, model, action, args, next) {
   const isUpdateAction = action === "update" || action === "updateMany";
   if (hasColumnHooks && isUpdateAction) {
     fields = hookRegistry_default.getRelevantFields(modelName);
-    prevData = await fetchAffectedRecords(prisma, modelName, args.where, fields);
+    prevData = await fetchAffectedRecords(prisma, model, args.where, fields);
     shouldRunColumnHooks = hookRegistry_default.shouldRunColumnHooks(modelName, prevData.length, { __flare: flareOptions });
   }
   await hookRegistry_default.runHooks("before", modelName, action, [args], prisma);
@@ -1021,7 +908,7 @@ async function executeHookLogic(prisma, model, action, args, next) {
   if (shouldRunColumnHooks && prevData.length > 0) {
     let newData = [];
     const ids = prevData.map((r) => r.id);
-    newData = await fetchAffectedRecords(prisma, modelName, { id: { in: ids } }, fields);
+    newData = await fetchAffectedRecords(prisma, model, { id: { in: ids } }, fields);
     for (let i = 0; i < prevData.length; i++) {
       const prevRecord = prevData[i];
       const newRecord = newData.find((record) => record.id === prevRecord.id);
@@ -1064,23 +951,102 @@ function registerHooksLegacy(prisma) {
     return executeHookLogic(prisma, model, action, args, () => next(params));
   });
 }
-async function registerHooks(prisma) {
-  let client;
+function registerHooks(prisma) {
   if (supportsPrisma6Middleware(prisma)) {
     registerHooksLegacy(prisma);
-    client = prisma;
+    return prisma;
   } else {
     const extension = createHooksExtension(prisma);
-    client = prisma.$extends(extension);
+    return prisma.$extends(extension);
   }
-  try {
-    const config = loadConfig();
-    const projectRoot = findProjectRoot(process.cwd());
-    const callbacksPath = path2.join(projectRoot, config.callbacksPath);
-    await loadCallbacks(callbacksPath);
-  } catch {
+}
+
+// src/core/extendedPrismaClient.ts
+function supportsPrisma6Middleware2(prisma) {
+  return typeof prisma.$use === "function";
+}
+var FlareClient = class extends PrismaClient2 {
+  constructor(options = {}) {
+    const { callbacks = true, ...prismaOptions } = options;
+    super(prismaOptions);
+    if (callbacks) {
+      if (supportsPrisma6Middleware2(this)) {
+        registerHooksLegacy(this);
+      } else {
+        const extension = createHooksExtension(this);
+        return this.$extends(extension);
+      }
+    }
+  }
+  /**
+   * Creates a new FlareBuilder instance for the specified model.
+   * @param modelName - The name of the model.
+   * @returns FlareBuilder instance
+   */
+  from(modelName) {
+    const key = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+    const model = this[key];
+    if (!model) {
+      throw new Error(`Model ${modelName} does not exist on PrismaClient.`);
+    }
+    return new FlareBuilder(model);
+  }
+  /**
+   * Executes a transaction with the FlareClient capabilities.
+   * @param fn - The transaction function.
+   * @param options - Transaction options.
+   * @returns The result of the transaction.
+   */
+  async transaction(fn, options) {
+    return super.$transaction(async (tx) => {
+      const extendedTx = new Proxy(tx, {
+        get: (target, prop, receiver) => {
+          if (prop === "from") {
+            return (modelName) => {
+              const key = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+              const model = target[key];
+              if (!model) {
+                throw new Error(`Model ${modelName} does not exist on TransactionClient.`);
+              }
+              return new FlareBuilder(model);
+            };
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+      return fn(extendedTx);
+    }, options);
   }
-  return client;
+};
+var ExtendedPrismaClient = FlareClient;
+
+// src/core/hooks.ts
+function normalizeModelName(model) {
+  return model.toLowerCase();
+}
+function beforeCreate(model, callback) {
+  hookRegistry_default.addHook(normalizeModelName(model), "create", "before", callback);
+}
+function beforeDelete(model, callback) {
+  hookRegistry_default.addHook(normalizeModelName(model), "delete", "before", callback);
+}
+function afterCreate(model, callback) {
+  hookRegistry_default.addHook(normalizeModelName(model), "create", "after", callback);
+}
+function afterDelete(model, callback) {
+  hookRegistry_default.addHook(normalizeModelName(model), "delete", "after", callback);
+}
+function beforeUpdate(model, callback) {
+  hookRegistry_default.addHook(normalizeModelName(model), "update", "before", callback);
+}
+function afterUpdate(model, callback) {
+  hookRegistry_default.addHook(normalizeModelName(model), "update", "after", callback);
+}
+function afterChange(model, column, callback) {
+  hookRegistry_default.addColumnHook(normalizeModelName(model), column, callback);
+}
+function afterUpsert(model, callback) {
+  hookRegistry_default.addHook(normalizeModelName(model), "upsert", "after", callback);
 }
 
 // src/core/adapters/postgres.ts
@@ -1163,8 +1129,8 @@ function parseDatabaseUrl(url) {
 }
 
 // src/core/adapters/sqlite.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var SqliteAdapter = {
   name: "sqlite",
   matches(url) {
@@ -1172,13 +1138,13 @@ var SqliteAdapter = {
   },
   async create(url) {
     const filePath = parseSqliteUrl(url);
-    const dir = path3.dirname(filePath);
+    const dir = path2.dirname(filePath);
     try {
-      if (!fs3.existsSync(dir)) {
-        fs3.mkdirSync(dir, { recursive: true });
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
       }
-      if (!fs3.existsSync(filePath)) {
-        fs3.writeFileSync(filePath, "");
+      if (!fs2.existsSync(filePath)) {
+        fs2.writeFileSync(filePath, "");
         console.log(`\u2705 SQLite database created at "${filePath}"`);
       } else {
         console.log(`\u26A0\uFE0F  SQLite database already exists at "${filePath}"`);
@@ -1191,20 +1157,20 @@ var SqliteAdapter = {
   async drop(url) {
     const filePath = parseSqliteUrl(url);
     try {
-      if (fs3.existsSync(filePath)) {
-        fs3.unlinkSync(filePath);
+      if (fs2.existsSync(filePath)) {
+        fs2.unlinkSync(filePath);
         console.log(`\u2705 SQLite database at "${filePath}" dropped successfully.`);
       } else {
         console.log(`\u26A0\uFE0F  SQLite database does not exist at "${filePath}"`);
       }
-      if (fs3.existsSync(`${filePath}-journal`)) {
-        fs3.unlinkSync(`${filePath}-journal`);
+      if (fs2.existsSync(`${filePath}-journal`)) {
+        fs2.unlinkSync(`${filePath}-journal`);
       }
-      if (fs3.existsSync(`${filePath}-wal`)) {
-        fs3.unlinkSync(`${filePath}-wal`);
+      if (fs2.existsSync(`${filePath}-wal`)) {
+        fs2.unlinkSync(`${filePath}-wal`);
       }
-      if (fs3.existsSync(`${filePath}-shm`)) {
-        fs3.unlinkSync(`${filePath}-shm`);
+      if (fs2.existsSync(`${filePath}-shm`)) {
+        fs2.unlinkSync(`${filePath}-shm`);
       }
     } catch (error) {
       console.error("\u274C Error dropping SQLite database:", error);
@@ -1214,8 +1180,8 @@ var SqliteAdapter = {
 };
 function parseSqliteUrl(url) {
   let cleanPath = url.replace(/^file:/, "");
-  if (!path3.isAbsolute(cleanPath)) {
-    cleanPath = path3.resolve(process.cwd(), cleanPath);
+  if (!path2.isAbsolute(cleanPath)) {
+    cleanPath = path2.resolve(process.cwd(), cleanPath);
   }
   return cleanPath;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-flare",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Prisma utilities package with callback system and query builder for chained operations",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -52,8 +52,7 @@
   },
   "dependencies": {
     "pg": "^8.16.3",
-    "pluralize": "^8.0.0",
-    "dotenv": "^17.2.3"
+    "pluralize": "^8.0.0"
   },
   "devDependencies": {
     "@prisma/client": "^5.18.0",

package/readme.md

@@ -73,27 +73,49 @@ prisma-flare automatically detects your Prisma version at runtime and uses the a
 Replace your standard `PrismaClient` with `FlareClient` in your database setup file (e.g., `src/db.ts` or `src/lib/prisma.ts`).
 
 ```typescript
-// src/db.ts
-import { FlareClient, registerHooks } from 'prisma-flare';
+// prisma/db.ts
+import './callbacks';  // Import generated index to register all hooks
+import { FlareClient } from 'prisma-flare';
 
-// Initialize hooks middleware and auto-load callbacks
-export const db = await registerHooks(new FlareClient());
+export const db = new FlareClient();
 ```
 
-`registerHooks()` is async and:
-- Registers the hooks middleware (using the appropriate API for your Prisma version)
-- Automatically loads all callback files from `prisma/callbacks` (or your configured path)
-- Returns the extended client instance
+`FlareClient` automatically attaches the callbacks middleware (using the appropriate API for your Prisma version). The callbacks import loads a generated barrel file that registers all your hooks - this pattern works in all environments (bundlers, Node.js, serverless, etc.).
 
-### 2. Generate Query Classes
+**With Prisma adapters:**
 
-Run the generator to create type-safe query classes for your specific schema.
+```typescript
+import './callbacks';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { FlareClient } from 'prisma-flare';
+
+const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL });
+
+export const db = new FlareClient({ adapter });
+```
+
+**Disable callbacks middleware:**
+
+```typescript
+import { FlareClient } from 'prisma-flare';
+
+// If you don't use callbacks, disable the middleware for slightly less overhead
+export const db = new FlareClient({ callbacks: false });
+```
+
+### 2. Generate Query Classes & Callbacks Index
+
+Run the generator to create type-safe query classes and the callbacks barrel file.
 
 ```bash
 npx prisma-flare generate
 ```
 
-By default, this will look for your `db` instance in `src/db` and output queries to `src/models`.
+This command:
+- Generates query classes based on your `schema.prisma`
+- Generates `prisma/callbacks/index.ts` that imports all your callback files
+
+**Important:** Re-run this command after adding new callback files to update the index.
 
 ### 3. Configuration (Optional)
 
@@ -110,7 +132,7 @@ If your project structure is different, create a `prisma-flare.config.json` in y
 
 - `modelsPath`: Where to generate the query classes (defaults to `prisma/models`).
 - `dbPath`: Path to the file exporting your `db` instance (relative to project root, defaults to `prisma/db`).
-- `callbacksPath`: Directory containing your callback/hook files (defaults to `prisma/callbacks`). All `.ts`/`.js` files in this directory are automatically loaded when `registerHooks()` is called.
+- `callbacksPath`: Directory containing your callback/hook files (defaults to `prisma/callbacks`). The generator creates an `index.ts` barrel file in this directory.
 - `envPath`: Path to your environment file (optional, defaults to `.env`).
 - `plurals`: Custom pluralization for model names (optional).
 
@@ -203,7 +225,7 @@ await DB.instance.transaction(async (tx) => {
 
 ### Callhooks & Middleware
 
-Define hooks to run logic before or after database operations. Create callback files in your callbacks directory (default: `prisma/callbacks`) and they'll be automatically loaded.
+Define hooks to run logic before or after database operations. Create callback files in your callbacks directory (default: `prisma/callbacks`), then run `npx prisma-flare generate` to update the index.
 
 ```typescript
 // prisma/callbacks/user.ts
@@ -235,7 +257,7 @@ afterChange('post', 'published', async (oldValue, newValue, record) => {
 });
 ```
 
-All files in the callbacks directory are automatically imported when `registerHooks()` is called. No manual loading required.
+After creating callback files, run `npx prisma-flare generate` to update the index. The generated `index.ts` imports all callbacks, which you then import in your db setup file.
 
 #### Hook Configuration
 
@@ -306,25 +328,22 @@ This prevents false positives when:
 
 #### Advanced Hook Registration
 
-For more control over hook registration, prisma-flare exports additional utilities:
+For advanced use cases, prisma-flare exports lower-level utilities:
 
 ```typescript
 import {
-  registerHooks,           // Auto-detects Prisma version + auto-loads callbacks (recommended)
-  registerHooksLegacy,     // Force legacy $use API (Prisma ≤6 only, no auto-load)
+  registerHooksLegacy,     // Force legacy $use API (Prisma ≤6 only)
   createHooksExtension,    // Get raw extension for manual use
-  loadCallbacks            // Manually load callbacks from a custom path
+  loadCallbacks            // Manually load callbacks at runtime (dev only)
 } from 'prisma-flare';
 
-// Option 1: Auto-detect with auto-loading (recommended)
-const db = await registerHooks(new FlareClient());
-
-// Option 2: Manual callback loading from custom path
+// Manual extension on raw PrismaClient (advanced)
 import { PrismaClient } from '@prisma/client';
 const prisma = new PrismaClient().$extends(createHooksExtension(new PrismaClient()));
-await loadCallbacks('/custom/path/to/callbacks');
 ```
 
+For most use cases, just use `new FlareClient()` which handles everything automatically.
+
 ## CLI Utilities
 
 Prisma Flare comes with a suite of CLI tools to manage your database workflow. It supports **PostgreSQL** and **SQLite** out of the box, and is extensible for other databases.