@nextsparkjs/core 0.1.0-beta.1

package/dist/lib/entities/external-api-generator.js

@@ -0,0 +1,388 @@
+import { NextResponse } from "next/server";
+import { generateEntityAPI } from "./api-generator";
+import { getEntityConfig } from "./registry";
+import { rateLimit } from "../rate-limit";
+import { validateAPIKey } from "../auth/api-keys";
+function generateExternalAPI(entityName, options = {}) {
+  const entityConfig = getEntityConfig(entityName);
+  if (!entityConfig) {
+    throw new Error(`Entity configuration not found: ${entityName}`);
+  }
+  if (!entityConfig.access.api) {
+    throw new Error(`Entity ${entityName} does not have external API enabled`);
+  }
+  const {
+    enableAPIKeyAuth = true,
+    enableRateLimit: enableRL = true,
+    enableCORS = true,
+    rateLimitConfig = {
+      windowMs: 60 * 1e3,
+      // 1 minute
+      maxRequests: 60
+      // Default rate limit
+    },
+    corsOptions = {
+      origins: ["*"],
+      methods: ["GET", "POST", "PATCH", "DELETE", "OPTIONS"],
+      headers: ["Content-Type", "Authorization", "X-API-Key"]
+    }
+  } = options;
+  const baseAPI = generateEntityAPI(entityName, {
+    ...options,
+    enableAuth: false
+    // We'll handle API key auth separately
+  });
+  return {
+    GET: wrapExternalHandler(baseAPI.GET, entityConfig, {
+      enableAPIKeyAuth,
+      enableRateLimit: enableRL,
+      enableCORS,
+      rateLimitConfig,
+      corsOptions,
+      action: "read"
+    }),
+    POST: wrapExternalHandler(baseAPI.POST, entityConfig, {
+      enableAPIKeyAuth,
+      enableRateLimit: enableRL,
+      enableCORS,
+      rateLimitConfig,
+      corsOptions,
+      action: "create"
+    }),
+    PATCH: wrapExternalHandler(baseAPI.PATCH, entityConfig, {
+      enableAPIKeyAuth,
+      enableRateLimit: enableRL,
+      enableCORS,
+      rateLimitConfig,
+      corsOptions,
+      action: "update"
+    }),
+    DELETE: wrapExternalHandler(baseAPI.DELETE, entityConfig, {
+      enableAPIKeyAuth,
+      enableRateLimit: enableRL,
+      enableCORS,
+      rateLimitConfig,
+      corsOptions,
+      action: "delete"
+    }),
+    OPTIONS: createOPTIONSHandler(corsOptions)
+  };
+}
+function wrapExternalHandler(baseHandler, entityConfig, options) {
+  return async (request, context) => {
+    var _a;
+    try {
+      if (options.enableCORS && request.method === "OPTIONS") {
+        return createOPTIONSHandler(options.corsOptions)(request);
+      }
+      const allowedMethods = ["GET", "POST", "PATCH", "DELETE"];
+      if (!allowedMethods.includes(request.method)) {
+        return createErrorResponse(405, "Method not allowed", {
+          allowedMethods
+        });
+      }
+      if (options.enableRateLimit && true) {
+        const rateLimitResult = await rateLimit({
+          key: getClientIdentifier(request),
+          windowMs: options.rateLimitConfig.windowMs,
+          maxRequests: options.rateLimitConfig.maxRequests
+        });
+        if (!rateLimitResult.success) {
+          return createErrorResponse(429, "Rate limit exceeded", {
+            limit: options.rateLimitConfig.maxRequests,
+            windowMs: options.rateLimitConfig.windowMs,
+            retryAfter: rateLimitResult.retryAfter
+          });
+        }
+      }
+      if (options.enableAPIKeyAuth) {
+        const apiKey = request.headers.get("X-API-Key") || ((_a = request.headers.get("Authorization")) == null ? void 0 : _a.replace("Bearer ", ""));
+        if (!apiKey) {
+          return createErrorResponse(401, "API key required", {
+            hint: "Include X-API-Key header or Authorization: Bearer <api-key>"
+          });
+        }
+        const keyValidation = await validateAPIKey(apiKey, {
+          requiredScopes: [`${entityConfig.slug}:${options.action}`],
+          entityName: entityConfig.slug
+        });
+        if (!keyValidation.valid) {
+          return createErrorResponse(401, "Invalid API key", {
+            reason: keyValidation.reason
+          });
+        }
+        request.headers.set("x-client-id", keyValidation.clientId || "");
+        request.headers.set("x-api-key-id", keyValidation.apiKeyId || "");
+        if (keyValidation.userId) {
+          request.headers.set("x-user-id", keyValidation.userId);
+        }
+      }
+      const response = await baseHandler(request, context);
+      if (options.enableCORS) {
+        addCORSHeaders(response, options.corsOptions);
+      }
+      response.headers.set("X-API-Version", "v1");
+      response.headers.set("X-Entity-Type", entityConfig.slug);
+      response.headers.set("X-Response-Time", Date.now().toString());
+      if (options.enableRateLimit) {
+        response.headers.set("X-RateLimit-Limit", options.rateLimitConfig.maxRequests.toString());
+        response.headers.set("X-RateLimit-Window", options.rateLimitConfig.windowMs.toString());
+      }
+      return response;
+    } catch (error) {
+      console.error(`External API error for ${entityConfig.slug}:`, error);
+      return createErrorResponse(500, "Internal server error", {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        entity: entityConfig.slug
+      });
+    }
+  };
+}
+function createOPTIONSHandler(corsOptions) {
+  return async (request) => {
+    const response = new NextResponse(null, { status: 204 });
+    addCORSHeaders(response, corsOptions, request);
+    return response;
+  };
+}
+function addCORSHeaders(response, corsOptions, request) {
+  const origin = request == null ? void 0 : request.headers.get("origin");
+  if (corsOptions.origins.includes("*") || origin && corsOptions.origins.includes(origin)) {
+    response.headers.set("Access-Control-Allow-Origin", origin || "*");
+  }
+  response.headers.set("Access-Control-Allow-Methods", corsOptions.methods.join(", "));
+  response.headers.set("Access-Control-Allow-Headers", corsOptions.headers.join(", "));
+  response.headers.set("Access-Control-Max-Age", "86400");
+  response.headers.set("Access-Control-Allow-Credentials", "true");
+}
+function createErrorResponse(status, message, details) {
+  return NextResponse.json({
+    error: {
+      status,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...details
+    }
+  }, { status });
+}
+function getClientIdentifier(request) {
+  const apiKeyId = request.headers.get("x-api-key-id");
+  const clientId = request.headers.get("x-client-id");
+  const ip = request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || "unknown";
+  return apiKeyId || clientId || ip;
+}
+function generateOpenAPISpec(entityName) {
+  const entityConfig = getEntityConfig(entityName);
+  if (!entityConfig) {
+    throw new Error(`Entity configuration not found: ${entityName}`);
+  }
+  const paths = {};
+  const basePath = `/api/v1/${entityName}`;
+  const entitySchema = {
+    type: "object",
+    properties: entityConfig.fields.reduce((props, field) => {
+      props[field.name] = {
+        type: getOpenAPIType(field.type),
+        description: field.display.description || field.display.label,
+        ...field.required ? {} : { nullable: true }
+      };
+      return props;
+    }, {}),
+    required: entityConfig.fields.filter((f) => f.required).map((f) => f.name)
+  };
+  paths[basePath] = {
+    get: {
+      summary: `List ${entityConfig.names.plural}`,
+      parameters: [
+        { name: "page", in: "query", schema: { type: "integer", default: 1 } },
+        { name: "limit", in: "query", schema: { type: "integer", default: 10, maximum: 100 } },
+        { name: "search", in: "query", schema: { type: "string" } },
+        { name: "sortBy", in: "query", schema: { type: "string" } },
+        { name: "sortOrder", in: "query", schema: { type: "string", enum: ["asc", "desc"] } },
+        ...entityConfig.childEntities ? [
+          { name: "children", in: "query", schema: { type: "string", description: "Comma-separated child entity names to include" } }
+        ] : []
+      ],
+      responses: {
+        200: {
+          description: `List of ${entityConfig.names.plural}`,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: { type: "array", items: { $ref: `#/components/schemas/${entityConfig.slug}` } },
+                  meta: {
+                    type: "object",
+                    properties: {
+                      total: { type: "integer" },
+                      page: { type: "integer" },
+                      limit: { type: "integer" },
+                      hasMore: { type: "boolean" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    post: {
+      summary: `Create ${entityConfig.names.singular}`,
+      requestBody: {
+        content: {
+          "application/json": {
+            schema: { $ref: `#/components/schemas/${entityConfig.slug}Create` }
+          }
+        }
+      },
+      responses: {
+        201: {
+          description: `Created ${entityConfig.names.singular}`,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: { $ref: `#/components/schemas/${entityConfig.slug}` }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  paths[`${basePath}/{id}`] = {
+    get: {
+      summary: `Get ${entityConfig.names.singular}`,
+      parameters: [
+        { name: "id", in: "path", required: true, schema: { type: "string" } },
+        ...entityConfig.childEntities ? [
+          { name: "children", in: "query", schema: { type: "string" } }
+        ] : []
+      ],
+      responses: {
+        200: {
+          description: entityConfig.names.singular,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: { $ref: `#/components/schemas/${entityConfig.slug}` }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    patch: {
+      summary: `Update ${entityConfig.names.singular}`,
+      parameters: [
+        { name: "id", in: "path", required: true, schema: { type: "string" } }
+      ],
+      requestBody: {
+        content: {
+          "application/json": {
+            schema: { $ref: `#/components/schemas/${entityConfig.slug}Update` }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: `Updated ${entityConfig.names.singular}`,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: { $ref: `#/components/schemas/${entityConfig.slug}` }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    delete: {
+      summary: `Delete ${entityConfig.names.singular}`,
+      parameters: [
+        { name: "id", in: "path", required: true, schema: { type: "string" } }
+      ],
+      responses: {
+        200: {
+          description: "Deleted successfully",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  return {
+    openapi: "3.0.0",
+    info: {
+      title: `${entityConfig.names.singular} API`,
+      version: "1.0.0",
+      description: `REST API for ${entityConfig.names.plural}`
+    },
+    paths,
+    components: {
+      schemas: {
+        [entityConfig.slug]: entitySchema,
+        [`${entityConfig.slug}Create`]: {
+          ...entitySchema,
+          required: entityConfig.fields.filter((f) => f.required && !f.api.readOnly).map((f) => f.name)
+        },
+        [`${entityConfig.slug}Update`]: {
+          ...entitySchema,
+          required: []
+        }
+      },
+      securitySchemes: {
+        ApiKeyAuth: {
+          type: "apiKey",
+          in: "header",
+          name: "X-API-Key"
+        }
+      }
+    },
+    security: [{ ApiKeyAuth: [] }]
+  };
+}
+function getOpenAPIType(fieldType) {
+  switch (fieldType) {
+    case "string":
+    case "text":
+    case "email":
+    case "url":
+    case "date":
+    case "datetime":
+    case "select":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "multiselect":
+      return "array";
+    case "json":
+      return "object";
+    default:
+      return "string";
+  }
+}
+export {
+  generateExternalAPI,
+  generateOpenAPISpec
+};

package/dist/lib/entities/helpers.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Entity Helpers - Phase 2 Teams Integration
+ *
+ * This file contains helper functions for entity-level operations,
+ * particularly for the two-layer security model:
+ * - RLS (Database): Team isolation only (identical for ALL entities)
+ * - App (Endpoints): User isolation based on access.shared config
+ */
+/**
+ * Determines if an entity should filter by userId at the app level
+ *
+ * The two-layer security model:
+ * - RLS at DB level handles team isolation (IDENTICAL for all entities)
+ * - App level handles user isolation based on access.shared config
+ *
+ * @param entityName - The name of the entity (e.g., 'tasks', 'customers')
+ * @returns True if the entity requires user isolation (access.shared === false)
+ *
+ * @example
+ * ```ts
+ * // Tasks with access.shared: false -> Only owner sees their records
+ * if (shouldFilterByUserId('tasks')) {
+ *   query += ' AND "userId" = $userId'
+ * }
+ *
+ * // Customers with access.shared: true -> All team members see all records
+ * if (shouldFilterByUserId('customers')) { // false
+ *   // No additional userId filter needed
+ * }
+ * ```
+ */
+export declare function shouldFilterByUserId(entityName: string): boolean;
+/**
+ * Gets the isolation mode for an entity
+ *
+ * @param entityName - The name of the entity
+ * @returns 'private' (user isolation) or 'shared' (team-wide access)
+ */
+export declare function getEntityIsolationMode(entityName: string): 'private' | 'shared';
+/**
+ * Applies user isolation to a query based on entity config
+ *
+ * This is the recommended way to build queries that respect the two-layer model.
+ *
+ * @param entityName - The name of the entity
+ * @param baseConditions - Base WHERE conditions (should already include teamId)
+ * @param userId - The current user's ID
+ * @returns Modified conditions with optional userId filter
+ *
+ * @example
+ * ```ts
+ * // In an API endpoint:
+ * const conditions = applyUserIsolation('tasks', { teamId }, userId)
+ * // If tasks has access.shared: false
+ * // -> conditions = { teamId, userId }
+ * // If access.shared: true
+ * // -> conditions = { teamId }
+ * ```
+ */
+export declare function applyUserIsolation(entityName: string, baseConditions: {
+    teamId: string;
+    [key: string]: unknown;
+}, userId: string): {
+    teamId: string;
+    userId?: string;
+    [key: string]: unknown;
+};
+/**
+ * Builds SQL WHERE clause for entity queries
+ *
+ * Generates the appropriate WHERE clause based on entity config:
+ * - Always includes teamId (RLS layer)
+ * - Optionally includes userId (App layer based on access.shared)
+ *
+ * @param entityName - The name of the entity
+ * @param teamIdParam - The parameter number for teamId (e.g., 1 -> $1)
+ * @param userIdParam - The parameter number for userId (e.g., 2 -> $2)
+ * @returns SQL WHERE conditions string and array of used parameters
+ *
+ * @example
+ * ```ts
+ * const { clause, params } = buildEntityWhereClause('tasks', 1, 2)
+ * // If tasks has access.shared: false
+ * // -> clause = '"teamId" = $1 AND "userId" = $2'
+ * // -> params = ['teamId', 'userId']
+ *
+ * // If customers has access.shared: true
+ * // -> clause = '"teamId" = $1'
+ * // -> params = ['teamId']
+ * ```
+ */
+export declare function buildEntityWhereClause(entityName: string, teamIdParam?: number, userIdParam?: number): {
+    clause: string;
+    params: string[];
+};
+/**
+ * Validates that a team context exists for entity operations
+ *
+ * @param teamId - The team ID from request headers
+ * @throws Error if teamId is missing
+ */
+export declare function validateTeamContext(teamId: string | null): asserts teamId is string;
+/**
+ * Gets required entity fields for creation
+ *
+ * Returns the fields that must be set when creating an entity:
+ * - userId: Always required (creator)
+ * - teamId: Always required (team context)
+ *
+ * @param userId - The current user's ID
+ * @param teamId - The active team's ID
+ * @returns Object with userId and teamId
+ */
+export declare function getEntityCreationFields(userId: string, teamId: string): {
+    userId: string;
+    teamId: string;
+};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/entities/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/entities/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAMhE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAE/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAC1D,MAAM,EAAE,MAAM,GACb;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAK7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,MAAU,EACvB,WAAW,GAAE,MAAU,GACtB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CActC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,MAAM,CAInF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAEpC"}

package/dist/lib/entities/helpers.js

@@ -0,0 +1,44 @@
+import { ENTITY_REGISTRY } from "./queries";
+function shouldFilterByUserId(entityName) {
+  var _a, _b;
+  const entityConfig = ENTITY_REGISTRY[entityName];
+  return ((_b = (_a = entityConfig == null ? void 0 : entityConfig.config) == null ? void 0 : _a.access) == null ? void 0 : _b.shared) === false;
+}
+function getEntityIsolationMode(entityName) {
+  return shouldFilterByUserId(entityName) ? "private" : "shared";
+}
+function applyUserIsolation(entityName, baseConditions, userId) {
+  if (shouldFilterByUserId(entityName)) {
+    return { ...baseConditions, userId };
+  }
+  return baseConditions;
+}
+function buildEntityWhereClause(entityName, teamIdParam = 1, userIdParam = 2) {
+  const baseClause = `"teamId" = $${teamIdParam}`;
+  if (shouldFilterByUserId(entityName)) {
+    return {
+      clause: `${baseClause} AND "userId" = $${userIdParam}`,
+      params: ["teamId", "userId"]
+    };
+  }
+  return {
+    clause: baseClause,
+    params: ["teamId"]
+  };
+}
+function validateTeamContext(teamId) {
+  if (!teamId) {
+    throw new Error("No team context provided. Include x-team-id header.");
+  }
+}
+function getEntityCreationFields(userId, teamId) {
+  return { userId, teamId };
+}
+export {
+  applyUserIsolation,
+  buildEntityWhereClause,
+  getEntityCreationFields,
+  getEntityIsolationMode,
+  shouldFilterByUserId,
+  validateTeamContext
+};

package/dist/lib/entities/hooks.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Entity Hook System
+ *
+ * Provides lifecycle hooks for entities with support for plan limits,
+ * flag system, child entities, and comprehensive hook management.
+ */
+import type { HookFunction, HookContext, HookResult, CRUDOperation, EntityConfig } from './types';
+/**
+ * Hook execution priority levels
+ */
+export declare enum HookPriority {
+    HIGHEST = 0,
+    HIGH = 10,
+    NORMAL = 50,
+    LOW = 90,
+    LOWEST = 100
+}
+/**
+ * Hook registration with priority
+ */
+interface HookRegistration {
+    hook: HookFunction;
+    priority: HookPriority;
+    name?: string;
+}
+/**
+ * Hook execution statistics
+ */
+interface HookStats {
+    entityName: string;
+    hookType: string;
+    executionCount: number;
+    averageExecutionTime: number;
+    lastExecuted: Date;
+}
+/**
+ * EntityHookManager - Manages lifecycle hooks for entities
+ */
+export declare class EntityHookManager {
+    private hooks;
+    private stats;
+    private enabled;
+    /**
+     * Register a hook for a specific entity and hook type
+     */
+    registerHook(entityName: string, hookType: string, hook: HookFunction, priority?: HookPriority, name?: string): void;
+    /**
+     * Register hooks from entity configuration
+     */
+    registerEntityHooks(config: EntityConfig): void;
+    /**
+     * Execute hooks for a specific entity and hook type
+     */
+    executeHooks(entityName: string, hookType: string, context: HookContext): Promise<HookResult>;
+    /**
+     * Execute before hooks (can modify data and stop execution)
+     */
+    executeBeforeHooks(entityName: string, operation: CRUDOperation, context: HookContext): Promise<HookResult>;
+    /**
+     * Execute after hooks (notifications, cleanup, etc.)
+     */
+    executeAfterHooks(entityName: string, operation: CRUDOperation, context: HookContext): Promise<void>;
+    /**
+     * Execute plan limit hooks
+     */
+    executePlanLimitHooks(entityName: string, limitType: 'reached' | 'upgrade', context: HookContext): Promise<HookResult>;
+    /**
+     * Execute flag system hooks
+     */
+    executeFlagHooks(entityName: string, flagEvent: 'conflict' | 'granted' | 'denied', context: HookContext): Promise<HookResult>;
+    /**
+     * Execute child entity hooks
+     */
+    executeChildHooks(parentEntityName: string, childName: string, hookType: string, context: HookContext): Promise<HookResult>;
+    /**
+     * Remove hooks for an entity
+     */
+    removeEntityHooks(entityName: string): void;
+    /**
+     * Remove specific hook
+     */
+    removeHook(entityName: string, hookType: string, hookName?: string): void;
+    /**
+     * Get registered hooks for entity
+     */
+    getEntityHooks(entityName: string): Record<string, HookRegistration[]>;
+    /**
+     * Update hook execution statistics
+     */
+    private updateStats;
+    /**
+     * Get hook execution statistics
+     */
+    getStats(): HookStats[];
+    /**
+     * Enable/disable hook execution
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Clear all hooks and stats
+     */
+    clear(): void;
+    /**
+     * Get total number of registered hooks
+     */
+    getHookCount(): number;
+}
+export declare const entityHookManager: EntityHookManager;
+export declare function registerHook(entityName: string, hookType: string, hook: HookFunction, priority?: HookPriority, name?: string): void;
+export declare function executeEntityHooks(entityName: string, hookType: string, context: HookContext): Promise<HookResult>;
+export declare function executeBeforeHooks(entityName: string, operation: CRUDOperation, context: HookContext): Promise<HookResult>;
+export declare function executeAfterHooks(entityName: string, operation: CRUDOperation, context: HookContext): Promise<void>;
+/**
+ * Built-in hook: Log entity operations
+ */
+export declare const logOperationHook: HookFunction;
+/**
+ * Built-in hook: Validate required fields
+ */
+export declare const validateRequiredFieldsHook: HookFunction;
+/**
+ * Built-in hook: Check plan limits before creation
+ */
+export declare const checkPlanLimitsHook: HookFunction;
+/**
+ * Built-in hook: Audit trail for sensitive operations
+ */
+export declare const auditTrailHook: HookFunction;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/lib/entities/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/lib/entities/hooks.ts"],"names":[],"mappings":"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"}