prisma-flare 1.0.0

package/dist/core/hooks.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  afterChange: () => afterChange,
+  afterCreate: () => afterCreate,
+  afterDelete: () => afterDelete,
+  afterUpdate: () => afterUpdate,
+  afterUpsert: () => afterUpsert,
+  beforeCreate: () => beforeCreate,
+  beforeDelete: () => beforeDelete,
+  beforeUpdate: () => beforeUpdate
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// src/core/hookRegistry.ts
+function valuesEqual(a, b) {
+  if (a == null && b == null) return true;
+  if (a == null || b == null) return false;
+  if (a === b) return true;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (typeof a.toDecimalPlaces === "function" && typeof b.toDecimalPlaces === "function") {
+    return a.toString() === b.toString();
+  }
+  if (typeof a === "bigint" && typeof b === "bigint") {
+    return a === b;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
+    }
+  }
+  return a === b;
+}
+var DEFAULT_CONFIG = {
+  enableColumnHooks: true,
+  maxRefetch: 1e3,
+  warnOnSkip: true
+};
+var HookRegistry = class {
+  constructor() {
+    this.hooks = {
+      before: {},
+      after: {}
+    };
+    this.columnHooks = {
+      afterChange: {}
+    };
+    this.fieldCache = {};
+    this.modelsWithColumnHooks = /* @__PURE__ */ new Set();
+    this.config = { ...DEFAULT_CONFIG };
+  }
+  /**
+   * Configure the hook system.
+   * @param config - Partial configuration to merge with defaults
+   * 
+   * @example
+   * // Disable column hooks globally for performance
+   * hookRegistry.configure({ enableColumnHooks: false });
+   * 
+   * @example
+   * // Increase maxRefetch limit
+   * hookRegistry.configure({ maxRefetch: 5000 });
+   * 
+   * @example
+   * // Disable limit entirely (use with caution)
+   * hookRegistry.configure({ maxRefetch: Infinity });
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get current configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  addHook(model, action, timing, fn) {
+    const key = `${model}:${action}`;
+    if (!this.hooks[timing][key]) {
+      this.hooks[timing][key] = [];
+    }
+    this.hooks[timing][key].push(fn);
+  }
+  addColumnHook(model, column, fn) {
+    const key = `${model}:${column}`;
+    if (!this.columnHooks.afterChange[key]) {
+      this.columnHooks.afterChange[key] = [];
+    }
+    this.columnHooks.afterChange[key].push(fn);
+    this.modelsWithColumnHooks.add(model);
+  }
+  async runHooks(timing, model, action, args, prisma) {
+    const key = `${model}:${action}`;
+    const hooks = this.hooks[timing]?.[key] ?? [];
+    if (timing === "after") {
+      await Promise.all(hooks.map((hook) => hook(...args, prisma)));
+    } else {
+      for (const hook of hooks) {
+        await hook(...args, prisma);
+      }
+    }
+  }
+  async runColumnHooks(model, newData, prevData, prisma) {
+    const promises = [];
+    for (const column in newData) {
+      const key = `${model}:${column}`;
+      const hooks = this.columnHooks.afterChange[key];
+      if (hooks && !valuesEqual(newData[column], prevData[column])) {
+        for (const hook of hooks) {
+          promises.push(hook(prevData[column], newData[column], newData, prisma));
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  hasColumnHooks(model) {
+    return this.modelsWithColumnHooks.has(model);
+  }
+  /**
+   * Check if column hooks should run for an operation.
+   * Takes into account global config, record count limits, and per-call options.
+   * 
+   * @param model - The model name
+   * @param recordCount - Number of records affected (for maxRefetch check)
+   * @param args - The operation args (to check for __flare skip option)
+   * @returns Whether column hooks should execute
+   */
+  shouldRunColumnHooks(model, recordCount, args) {
+    if (args?.__flare?.skipColumnHooks === true) {
+      return false;
+    }
+    if (!this.config.enableColumnHooks) {
+      return false;
+    }
+    if (!this.modelsWithColumnHooks.has(model)) {
+      return false;
+    }
+    if (this.config.maxRefetch > 0 && recordCount > this.config.maxRefetch) {
+      if (this.config.warnOnSkip) {
+        console.warn(
+          `[prisma-flare] Skipping column hooks for ${model}: ${recordCount} records exceeds maxRefetch limit of ${this.config.maxRefetch}. Configure via hookRegistry.configure({ maxRefetch: ... })`
+        );
+      }
+      return false;
+    }
+    return true;
+  }
+  getRelevantFields(model) {
+    if (this.fieldCache[model]) {
+      return this.fieldCache[model];
+    }
+    const fields = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(this.columnHooks.afterChange)) {
+      if (key.startsWith(`${model}:`)) {
+        const [, column] = key.split(":");
+        fields.add(column);
+      }
+    }
+    fields.add("id");
+    const result = Array.from(fields).reduce((acc, field) => {
+      acc[field] = true;
+      return acc;
+    }, {});
+    this.fieldCache[model] = result;
+    return result;
+  }
+  /**
+   * Clear all registered hooks (useful for testing)
+   */
+  clearAll() {
+    this.hooks.before = {};
+    this.hooks.after = {};
+    this.columnHooks.afterChange = {};
+    this.fieldCache = {};
+    this.modelsWithColumnHooks.clear();
+    this.config = { ...DEFAULT_CONFIG };
+  }
+};
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterChange,
+  afterCreate,
+  afterDelete,
+  afterUpdate,
+  afterUpsert,
+  beforeCreate,
+  beforeDelete,
+  beforeUpdate
+});

package/dist/core/hooks.d.cts

@@ -0,0 +1,13 @@
+import { M as ModelName, B as BeforeHookCallback, j as AfterHookCallback, k as ColumnChangeCallback } from '../prisma.types-nGNe1CG8.cjs';
+import '@prisma/client';
+
+declare function beforeCreate<T extends ModelName>(model: T, callback: BeforeHookCallback<T>): void;
+declare function beforeDelete<T extends ModelName>(model: T, callback: BeforeHookCallback<T>): void;
+declare function afterCreate<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+declare function afterDelete<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+declare function beforeUpdate<T extends ModelName>(model: T, callback: BeforeHookCallback<T>): void;
+declare function afterUpdate<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+declare function afterChange<T extends ModelName>(model: T, column: string, callback: ColumnChangeCallback<T>): void;
+declare function afterUpsert<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+
+export { afterChange, afterCreate, afterDelete, afterUpdate, afterUpsert, beforeCreate, beforeDelete, beforeUpdate };

package/dist/core/hooks.d.ts

@@ -0,0 +1,13 @@
+import { M as ModelName, B as BeforeHookCallback, j as AfterHookCallback, k as ColumnChangeCallback } from '../prisma.types-nGNe1CG8.js';
+import '@prisma/client';
+
+declare function beforeCreate<T extends ModelName>(model: T, callback: BeforeHookCallback<T>): void;
+declare function beforeDelete<T extends ModelName>(model: T, callback: BeforeHookCallback<T>): void;
+declare function afterCreate<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+declare function afterDelete<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+declare function beforeUpdate<T extends ModelName>(model: T, callback: BeforeHookCallback<T>): void;
+declare function afterUpdate<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+declare function afterChange<T extends ModelName>(model: T, column: string, callback: ColumnChangeCallback<T>): void;
+declare function afterUpsert<T extends ModelName>(model: T, callback: AfterHookCallback<T>): void;
+
+export { afterChange, afterCreate, afterDelete, afterUpdate, afterUpsert, beforeCreate, beforeDelete, beforeUpdate };

package/dist/core/hooks.js

@@ -0,0 +1,209 @@
+// src/core/hookRegistry.ts
+function valuesEqual(a, b) {
+  if (a == null && b == null) return true;
+  if (a == null || b == null) return false;
+  if (a === b) return true;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (typeof a.toDecimalPlaces === "function" && typeof b.toDecimalPlaces === "function") {
+    return a.toString() === b.toString();
+  }
+  if (typeof a === "bigint" && typeof b === "bigint") {
+    return a === b;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
+    }
+  }
+  return a === b;
+}
+var DEFAULT_CONFIG = {
+  enableColumnHooks: true,
+  maxRefetch: 1e3,
+  warnOnSkip: true
+};
+var HookRegistry = class {
+  constructor() {
+    this.hooks = {
+      before: {},
+      after: {}
+    };
+    this.columnHooks = {
+      afterChange: {}
+    };
+    this.fieldCache = {};
+    this.modelsWithColumnHooks = /* @__PURE__ */ new Set();
+    this.config = { ...DEFAULT_CONFIG };
+  }
+  /**
+   * Configure the hook system.
+   * @param config - Partial configuration to merge with defaults
+   * 
+   * @example
+   * // Disable column hooks globally for performance
+   * hookRegistry.configure({ enableColumnHooks: false });
+   * 
+   * @example
+   * // Increase maxRefetch limit
+   * hookRegistry.configure({ maxRefetch: 5000 });
+   * 
+   * @example
+   * // Disable limit entirely (use with caution)
+   * hookRegistry.configure({ maxRefetch: Infinity });
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get current configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  addHook(model, action, timing, fn) {
+    const key = `${model}:${action}`;
+    if (!this.hooks[timing][key]) {
+      this.hooks[timing][key] = [];
+    }
+    this.hooks[timing][key].push(fn);
+  }
+  addColumnHook(model, column, fn) {
+    const key = `${model}:${column}`;
+    if (!this.columnHooks.afterChange[key]) {
+      this.columnHooks.afterChange[key] = [];
+    }
+    this.columnHooks.afterChange[key].push(fn);
+    this.modelsWithColumnHooks.add(model);
+  }
+  async runHooks(timing, model, action, args, prisma) {
+    const key = `${model}:${action}`;
+    const hooks = this.hooks[timing]?.[key] ?? [];
+    if (timing === "after") {
+      await Promise.all(hooks.map((hook) => hook(...args, prisma)));
+    } else {
+      for (const hook of hooks) {
+        await hook(...args, prisma);
+      }
+    }
+  }
+  async runColumnHooks(model, newData, prevData, prisma) {
+    const promises = [];
+    for (const column in newData) {
+      const key = `${model}:${column}`;
+      const hooks = this.columnHooks.afterChange[key];
+      if (hooks && !valuesEqual(newData[column], prevData[column])) {
+        for (const hook of hooks) {
+          promises.push(hook(prevData[column], newData[column], newData, prisma));
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  hasColumnHooks(model) {
+    return this.modelsWithColumnHooks.has(model);
+  }
+  /**
+   * Check if column hooks should run for an operation.
+   * Takes into account global config, record count limits, and per-call options.
+   * 
+   * @param model - The model name
+   * @param recordCount - Number of records affected (for maxRefetch check)
+   * @param args - The operation args (to check for __flare skip option)
+   * @returns Whether column hooks should execute
+   */
+  shouldRunColumnHooks(model, recordCount, args) {
+    if (args?.__flare?.skipColumnHooks === true) {
+      return false;
+    }
+    if (!this.config.enableColumnHooks) {
+      return false;
+    }
+    if (!this.modelsWithColumnHooks.has(model)) {
+      return false;
+    }
+    if (this.config.maxRefetch > 0 && recordCount > this.config.maxRefetch) {
+      if (this.config.warnOnSkip) {
+        console.warn(
+          `[prisma-flare] Skipping column hooks for ${model}: ${recordCount} records exceeds maxRefetch limit of ${this.config.maxRefetch}. Configure via hookRegistry.configure({ maxRefetch: ... })`
+        );
+      }
+      return false;
+    }
+    return true;
+  }
+  getRelevantFields(model) {
+    if (this.fieldCache[model]) {
+      return this.fieldCache[model];
+    }
+    const fields = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(this.columnHooks.afterChange)) {
+      if (key.startsWith(`${model}:`)) {
+        const [, column] = key.split(":");
+        fields.add(column);
+      }
+    }
+    fields.add("id");
+    const result = Array.from(fields).reduce((acc, field) => {
+      acc[field] = true;
+      return acc;
+    }, {});
+    this.fieldCache[model] = result;
+    return result;
+  }
+  /**
+   * Clear all registered hooks (useful for testing)
+   */
+  clearAll() {
+    this.hooks.before = {};
+    this.hooks.after = {};
+    this.columnHooks.afterChange = {};
+    this.fieldCache = {};
+    this.modelsWithColumnHooks.clear();
+    this.config = { ...DEFAULT_CONFIG };
+  }
+};
+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);
+}
+export {
+  afterChange,
+  afterCreate,
+  afterDelete,
+  afterUpdate,
+  afterUpsert,
+  beforeCreate,
+  beforeDelete,
+  beforeUpdate
+};

package/dist/generated.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/generated.ts
+var generated_exports = {};
+__export(generated_exports, {
+  DB: () => DB
+});
+module.exports = __toCommonJS(generated_exports);
+var DB = class {
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DB
+});

package/dist/generated.d.cts

@@ -0,0 +1,4 @@
+declare class DB {
+}
+
+export { DB };

package/dist/generated.d.ts

@@ -0,0 +1,4 @@
+declare class DB {
+}
+
+export { DB };

package/dist/generated.js

@@ -0,0 +1,6 @@
+// src/generated.ts
+var DB = class {
+};
+export {
+  DB
+};