@nextsparkjs/core 0.1.0-beta.7 → 0.1.0-beta.70

package/dist/lib/config/config-sync.js

@@ -1,33 +1,35 @@
-import { DEFAULT_APP_CONFIG } from "./app.config";
-import { DEFAULT_DASHBOARD_CONFIG } from "./dashboard.config";
-import { ThemeService } from "../services/theme.service";
-import { mergeConfigs } from "../utils/config-merge";
-import { mergeRolesConfig } from "./roles-merge";
+import { DEFAULT_APP_CONFIG } from "./app.config.js";
+import { DEFAULT_DASHBOARD_CONFIG } from "./dashboard.config.js";
+import { ThemeService } from "../services/theme.service.js";
+import { mergeConfigs } from "../utils/config-merge.js";
+import { mergeRolesConfig } from "./roles-merge.js";
 import {
   AVAILABLE_ROLES as REGISTRY_AVAILABLE_ROLES,
   ROLE_HIERARCHY as REGISTRY_ROLE_HIERARCHY,
   ROLE_DISPLAY_NAMES as REGISTRY_ROLE_DISPLAY_NAMES,
   ROLE_DESCRIPTIONS as REGISTRY_ROLE_DESCRIPTIONS
 } from "@nextsparkjs/registries/permissions-registry";
-function loadAppConfig() {
+const DEBUG_CONFIG = process.env.NEXTSPARK_DEBUG_CONFIG === "true";
+const globalCache = globalThis;
+function loadAppConfigInternal() {
   const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME;
-  if (process.env.NODE_ENV === "development") {
+  if (DEBUG_CONFIG) {
     console.log("[config-sync] Loading app config for theme:", activeTheme);
   }
   if (!activeTheme) {
-    if (process.env.NODE_ENV === "development") {
+    if (DEBUG_CONFIG) {
       console.log("[config-sync] No active theme, using default app config");
     }
     return DEFAULT_APP_CONFIG;
   }
   const themeConfigOverrides = ThemeService.getAppConfig(activeTheme);
   if (!themeConfigOverrides) {
-    if (process.env.NODE_ENV === "development") {
+    if (DEBUG_CONFIG) {
       console.log("[config-sync] Theme has no app config overrides, using default");
     }
     return DEFAULT_APP_CONFIG;
   }
-  if (process.env.NODE_ENV === "development") {
+  if (DEBUG_CONFIG) {
     console.log("[config-sync] Theme app config overrides loaded from registry");
   }
   const mergedConfig = mergeConfigs(DEFAULT_APP_CONFIG, themeConfigOverrides);
@@ -47,34 +49,41 @@ function loadAppConfig() {
       descriptions: REGISTRY_ROLE_DESCRIPTIONS
     };
   }
-  if (process.env.NODE_ENV === "development") {
+  if (DEBUG_CONFIG) {
     console.log("[config-sync] App config merged successfully");
   }
   return mergedConfig;
 }
-function loadDashboardConfig() {
+function loadAppConfig() {
+  if (globalCache.__nextspark_app_config) {
+    return globalCache.__nextspark_app_config;
+  }
+  globalCache.__nextspark_app_config = loadAppConfigInternal();
+  return globalCache.__nextspark_app_config;
+}
+function loadDashboardConfigInternal() {
   const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME;
-  if (process.env.NODE_ENV === "development") {
+  if (DEBUG_CONFIG) {
     console.log("[config-sync] activeTheme:", activeTheme);
   }
   if (!activeTheme) {
-    if (process.env.NODE_ENV === "development") {
+    if (DEBUG_CONFIG) {
       console.log("[config-sync] No active theme, using default config");
     }
     return DEFAULT_DASHBOARD_CONFIG;
   }
   const themeConfig = ThemeService.getDashboardConfig(activeTheme);
   if (!themeConfig) {
-    if (process.env.NODE_ENV === "development") {
+    if (DEBUG_CONFIG) {
       console.log("[config-sync] Theme has no dashboard config, using default");
     }
     return DEFAULT_DASHBOARD_CONFIG;
   }
-  if (process.env.NODE_ENV === "development") {
+  if (DEBUG_CONFIG) {
     console.log("[config-sync] Theme config loaded (validation skipped)");
   }
   const mergedConfig = mergeConfigs(DEFAULT_DASHBOARD_CONFIG, themeConfig);
-  if (process.env.NODE_ENV === "development") {
+  if (DEBUG_CONFIG) {
     console.log("[config-sync] Config merged successfully");
     console.log("[config-sync] Merged config has helper functions:", {
       isSettingsPageEnabled: typeof mergedConfig.isSettingsPageEnabled === "function",
@@ -84,17 +93,31 @@ function loadDashboardConfig() {
   }
   return mergedConfig;
 }
-function loadDevConfig() {
+function loadDashboardConfig() {
+  if (globalCache.__nextspark_dashboard_config) {
+    return globalCache.__nextspark_dashboard_config;
+  }
+  globalCache.__nextspark_dashboard_config = loadDashboardConfigInternal();
+  return globalCache.__nextspark_dashboard_config;
+}
+function loadDevConfigInternal() {
   const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME;
   if (!activeTheme) {
     return null;
   }
   const devConfig = ThemeService.getDevConfig(activeTheme);
-  if (process.env.NODE_ENV === "development" && devConfig) {
+  if (DEBUG_CONFIG && devConfig) {
     console.log("[config-sync] Dev config loaded for theme:", activeTheme);
   }
   return devConfig;
 }
+function loadDevConfig() {
+  if (globalCache.__nextspark_dev_config !== void 0) {
+    return globalCache.__nextspark_dev_config;
+  }
+  globalCache.__nextspark_dev_config = loadDevConfigInternal();
+  return globalCache.__nextspark_dev_config;
+}
 const APP_CONFIG_MERGED = loadAppConfig();
 const DASHBOARD_CONFIG = loadDashboardConfig();
 const DEV_CONFIG = loadDevConfig();

package/dist/lib/config/dashboard.config.js

@@ -72,6 +72,20 @@ const DEFAULT_DASHBOARD_CONFIG = {
     devtoolsAccess: {
       enabled: true
     },
+    /**
+     * Settings menu dropdown (gear icon)
+     * Contains links to admin-level features
+     */
+    settingsMenu: {
+      enabled: true,
+      links: [
+        {
+          label: "navigation.patterns",
+          href: "/dashboard/patterns",
+          icon: "layers"
+        }
+      ]
+    },
     /**
      * User menu dropdown
      */

package/dist/lib/config/index.d.js

@@ -1,7 +1,7 @@
-export * from "./config-utils";
-export * from "./config-loader";
-export * from "./config-sync";
-import { defineConfig } from "./nextspark-types";
+export * from "./config-utils.js";
+export * from "./config-loader.js";
+export * from "./config-sync.js";
+import { defineConfig } from "./nextspark-types.js";
 export {
   defineConfig
 };

package/dist/lib/config/index.js

@@ -1,7 +1,7 @@
-export * from "./config-utils";
-export * from "./config-loader";
-export * from "./config-sync";
-import { defineConfig } from "./nextspark-types";
+export * from "./config-utils.js";
+export * from "./config-loader.js";
+export * from "./config-sync.js";
+import { defineConfig } from "./nextspark-types.js";
 export {
   defineConfig
 };

package/dist/lib/db.js

@@ -1,16 +1,88 @@
 import { Pool } from "pg";
+import { isValidUUID } from "./api/helpers.js";
+let activeConnections = 0;
+let isShuttingDown = false;
+let shutdownPromise = null;
+function parseSSLConfig(databaseUrl2) {
+  var _a;
+  const isProduction = process.env.NODE_ENV === "production";
+  if (!databaseUrl2) {
+    return isProduction ? { rejectUnauthorized: true } : false;
+  }
+  try {
+    const url = new URL(databaseUrl2);
+    const sslmode = (_a = url.searchParams.get("sslmode")) == null ? void 0 : _a.trim().toLowerCase();
+    if (sslmode) {
+      switch (sslmode) {
+        case "disable":
+          if (isProduction) {
+            console.warn("[DB] WARNING: SSL disabled in production environment. This is insecure!");
+          }
+          return false;
+        case "require":
+        case "prefer":
+        case "allow":
+          return { rejectUnauthorized: false };
+        case "verify-ca":
+        case "verify-full":
+          return { rejectUnauthorized: true };
+        default:
+          console.warn(`[DB] Unknown sslmode value: "${sslmode}". Using environment defaults.`);
+      }
+    }
+    return isProduction ? { rejectUnauthorized: true } : false;
+  } catch {
+    if (databaseUrl2.includes("sslmode=disable")) {
+      return false;
+    }
+    return isProduction ? { rejectUnauthorized: true } : false;
+  }
+}
+const databaseUrl = process.env.DATABASE_URL || "";
+const sslConfig = parseSSLConfig(databaseUrl);
 const pool = new Pool({
-  connectionString: process.env.DATABASE_URL,
-  ssl: { rejectUnauthorized: false },
+  connectionString: databaseUrl,
+  ssl: sslConfig,
   max: 20,
   idleTimeoutMillis: 3e4,
   connectionTimeoutMillis: 1e4
 });
-async function queryWithRLS(query2, params = [], userId) {
+function validateUserId(userId) {
+  const isProduction = process.env.NODE_ENV === "production";
+  if (isProduction) {
+    if (!isValidUUID(userId)) {
+      throw new Error("Invalid userId format - must be valid UUID");
+    }
+    return;
+  }
+  if (userId.includes("'") || userId.includes('"') || userId.includes("\\") || userId.includes(";")) {
+    throw new Error("Invalid userId format: contains dangerous characters");
+  }
+  if (/[\x00-\x1f]/.test(userId)) {
+    throw new Error("Invalid userId format: contains control characters");
+  }
+  if (userId.length > 255) {
+    throw new Error("Invalid userId format: too long");
+  }
+}
+async function acquireClient() {
+  if (isShuttingDown) {
+    throw new Error("Database pool is shutting down. Cannot acquire new connections.");
+  }
   const client = await pool.connect();
+  activeConnections++;
+  return client;
+}
+function releaseClient(client) {
+  activeConnections = Math.max(0, activeConnections - 1);
+  client.release();
+}
+async function queryWithRLS(query2, params = [], userId) {
+  const client = await acquireClient();
   try {
     await client.query("BEGIN");
     if (userId) {
+      validateUserId(userId);
       await client.query(`SET LOCAL app.user_id = '${userId.replace(/'/g, "''")}'`);
     }
     const result = await client.query(query2, params);
@@ -20,7 +92,7 @@ async function queryWithRLS(query2, params = [], userId) {
     await client.query("ROLLBACK");
     throw error;
   } finally {
-    client.release();
+    releaseClient(client);
   }
 }
 async function queryOneWithRLS(query2, params = [], userId) {
@@ -28,10 +100,11 @@ async function queryOneWithRLS(query2, params = [], userId) {
   return rows[0] || null;
 }
 async function mutateWithRLS(query2, params = [], userId) {
-  const client = await pool.connect();
+  const client = await acquireClient();
   try {
     await client.query("BEGIN");
     if (userId) {
+      validateUserId(userId);
       await client.query(`SET LOCAL app.user_id = '${userId.replace(/'/g, "''")}'`);
     }
     const result = await client.query(query2, params);
@@ -44,14 +117,20 @@ async function mutateWithRLS(query2, params = [], userId) {
     await client.query("ROLLBACK");
     throw error;
   } finally {
-    client.release();
+    releaseClient(client);
   }
 }
 async function getTransactionClient(userId) {
-  const client = await pool.connect();
-  await client.query("BEGIN");
-  if (userId) {
-    await client.query(`SET LOCAL app.user_id = '${userId.replace(/'/g, "''")}'`);
+  const client = await acquireClient();
+  try {
+    await client.query("BEGIN");
+    if (userId) {
+      validateUserId(userId);
+      await client.query(`SET LOCAL app.user_id = '${userId.replace(/'/g, "''")}'`);
+    }
+  } catch (error) {
+    releaseClient(client);
+    throw error;
   }
   return {
     query: (query2, params = []) => client.query(query2, params).then((r) => r.rows),
@@ -59,11 +138,11 @@ async function getTransactionClient(userId) {
     mutate: (query2, params = []) => client.query(query2, params).then((r) => ({ rows: r.rows, rowCount: r.rowCount || 0 })),
     commit: async () => {
       await client.query("COMMIT");
-      client.release();
+      releaseClient(client);
     },
     rollback: async () => {
       await client.query("ROLLBACK");
-      client.release();
+      releaseClient(client);
     }
   };
 }
@@ -82,11 +161,90 @@ async function queryOne(text, params) {
   const result = await pool.query(text, params);
   return result.rows[0] || null;
 }
+function getPool() {
+  if (isShuttingDown) {
+    throw new Error("Database pool is shutting down. Cannot acquire new connections.");
+  }
+  return pool;
+}
+function isPoolHealthy() {
+  if (isShuttingDown) {
+    console.warn("[DB] Pool health check failed: shutting down");
+    return false;
+  }
+  const maxConnections = pool.options.max || 20;
+  const isExhausted = pool.totalCount >= maxConnections && pool.idleCount === 0 && pool.waitingCount > 10;
+  if (isExhausted) {
+    console.warn("[DB] Pool health check failed: pool exhausted", {
+      total: pool.totalCount,
+      idle: pool.idleCount,
+      waiting: pool.waitingCount
+    });
+    return false;
+  }
+  return true;
+}
+function getPoolStats() {
+  return {
+    total: pool.totalCount,
+    idle: pool.idleCount,
+    waiting: pool.waitingCount,
+    activeConnections,
+    isShuttingDown
+  };
+}
+async function gracefulShutdown(timeoutMs = 3e4) {
+  if (shutdownPromise) {
+    return shutdownPromise;
+  }
+  isShuttingDown = true;
+  console.log("[DB] Initiating graceful database shutdown...");
+  shutdownPromise = new Promise((resolve) => {
+    const startTime = Date.now();
+    let timeoutId = null;
+    const checkAndClose = async () => {
+      const elapsed = Date.now() - startTime;
+      if (activeConnections === 0 || elapsed >= timeoutMs) {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+        if (activeConnections > 0) {
+          console.warn(`[DB] Shutdown timeout reached. Forcing close with ${activeConnections} active connections.`);
+        } else {
+          console.log("[DB] All connections released. Closing pool...");
+        }
+        try {
+          await pool.end();
+          console.log("[DB] Database pool closed successfully.");
+        } catch (error) {
+          console.error("[DB] Error closing database pool:", error);
+        }
+        resolve();
+        return;
+      }
+      timeoutId = setTimeout(checkAndClose, 100);
+    };
+    checkAndClose();
+  });
+  return shutdownPromise;
+}
+process.on("SIGTERM", async () => {
+  console.log("[DB] SIGTERM received, initiating graceful shutdown...");
+  await gracefulShutdown();
+});
+process.on("SIGINT", async () => {
+  console.log("[DB] SIGINT received, initiating graceful shutdown...");
+  await gracefulShutdown();
+});
 async function checkDatabaseConnection() {
+  if (isShuttingDown) {
+    return false;
+  }
   try {
-    const client = await pool.connect();
+    const client = await acquireClient();
     await client.query("SELECT 1");
-    client.release();
+    releaseClient(client);
     return true;
   } catch (error) {
     console.error("Database connection failed:", error);
@@ -95,12 +253,18 @@ async function checkDatabaseConnection() {
 }
 export {
   checkDatabaseConnection,
+  getPool,
+  getPoolStats,
   getTransactionClient,
+  gracefulShutdown,
+  isPoolHealthy,
   mutateWithRLS,
+  parseSSLConfig,
   pool,
   query,
   queryOne,
   queryOneWithRLS,
   queryRows,
-  queryWithRLS
+  queryWithRLS,
+  validateUserId
 };

package/dist/lib/docs/parser.js

@@ -9,7 +9,7 @@ import {
   extractOrderFromFilename,
   cleanFilename,
   slugToTitle
-} from "./utils";
+} from "./utils.js";
 async function parseMarkdownFile(filePath) {
   const fileContent = fs.readFileSync(filePath, "utf-8");
   const { data, content } = matter(fileContent);

package/dist/lib/email/factory.js

@@ -1,5 +1,5 @@
-import { ResendProvider } from "./providers/resend";
-import { ConsoleProvider } from "./providers/console";
+import { ResendProvider } from "./providers/resend.js";
+import { ConsoleProvider } from "./providers/console.js";
 class EmailFactory {
   static instance = null;
   static create(options = {}) {

package/dist/lib/email/index.d.js

@@ -1,3 +1,3 @@
-export * from "./types";
-export * from "./factory";
-export * from "./templates";
+export * from "./types.js";
+export * from "./factory.js";
+export * from "./templates.js";

package/dist/lib/email/index.js

@@ -1,3 +1,3 @@
-export * from "./types";
-export * from "./factory";
-export * from "./templates";
+export * from "./types.js";
+export * from "./factory.js";
+export * from "./templates.js";

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

@@ -1,8 +1,8 @@
 import { NextResponse } from "next/server";
 import { z } from "zod";
-import { getEntityConfig } from "./registry";
-import { executeEntityHooks } from "./hooks";
-import { auth } from "../auth";
+import { getEntityConfig } from "./registry.js";
+import { executeEntityHooks } from "./hooks.js";
+import { auth } from "../auth.js";
 function generateEntityAPI(entityName, options = {}) {
   const entityConfig = getEntityConfig(entityName);
   if (!entityConfig) {

package/dist/lib/entities/entity-hooks.js

@@ -1,4 +1,4 @@
-import { getGlobalHooks } from "../plugins/hook-system";
+import { getGlobalHooks } from "../plugins/hook-system.js";
 class EntityHookManager {
   hooks = getGlobalHooks();
   /**
@@ -205,14 +205,7 @@ class EntityHookManager {
       icon: null,
       fields: [],
       features: { enabled: true },
-      permissions: {
-        actions: [
-          { action: "read", label: "Read", roles: [] },
-          { action: "create", label: "Create", roles: [] },
-          { action: "update", label: "Update", roles: [] },
-          { action: "delete", label: "Delete", roles: [], dangerous: true }
-        ]
-      },
+      // Permissions are defined centrally in permissions.config.ts
       planLimits: { free: {}, starter: {}, premium: {} },
       routes: { list: "", detail: "" },
       hooks: {},
@@ -231,6 +224,8 @@ const afterEntityDelete = (entityName, id, userId) => entityHookManager.afterEnt
 const validateEntity = (entityName, data, operation) => entityHookManager.validateEntity(entityName, data, operation);
 const beforeEntityRead = (entityName, query, userId) => entityHookManager.beforeEntityRead(entityName, query, userId);
 const afterEntityRead = (entityName, results, query, userId) => entityHookManager.afterEntityRead(entityName, results, query, userId);
+import { initPatternUsageHooks } from "./pattern-usage-hooks.js";
+initPatternUsageHooks();
 export {
   EntityHookManager,
   afterEntityCreate,

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

@@ -1,8 +1,8 @@
 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";
+import { generateEntityAPI } from "./api-generator.js";
+import { getEntityConfig } from "./registry.js";
+import { rateLimit } from "../rate-limit.js";
+import { validateAPIKey } from "../auth/api-keys.js";
 function generateExternalAPI(entityName, options = {}) {
   const entityConfig = getEntityConfig(entityName);
   if (!entityConfig) {

package/dist/lib/entities/helpers.js

@@ -1,4 +1,4 @@
-import { getEntityRegistry } from "./queries";
+import { getEntityRegistry } from "./queries.js";
 function shouldFilterByUserId(entityName) {
   var _a, _b;
   const registry = getEntityRegistry();

package/dist/lib/entities/meta-adapter.js

@@ -1,4 +1,4 @@
-import { getEntityConfig, getAllEntityConfigs } from "./registry";
+import { getEntityConfig, getAllEntityConfigs } from "./registry.js";
 class MetaSystemAdapter {
   /**
    * Get meta configuration for an entity

package/dist/lib/entities/migration-helper.js

@@ -264,25 +264,6 @@ function generateRLSPolicies(entityConfig, tableName, includeComments) {
     using: "TRUE",
     comment: includeComments ? "Service role has full access" : void 0
   });
-  const crudActions = ["read", "create", "update", "delete"];
-  crudActions.forEach((action) => {
-    var _a, _b;
-    const actionConfig = (_b = (_a = entityConfig.permissions) == null ? void 0 : _a.actions) == null ? void 0 : _b.find((a) => a.action === action);
-    const roles = (actionConfig == null ? void 0 : actionConfig.roles) || [];
-    if (Array.isArray(roles)) {
-      roles.forEach((role) => {
-        if (role !== "superadmin") {
-          const policyAction = action.toUpperCase();
-          policies.push({
-            name: `${tableName}_${role}_${action}`,
-            action: policyAction,
-            using: hasUserField ? `auth.jwt() ->> 'role' = '${role}' AND (auth.uid() = user_id OR auth.jwt() ->> 'role' IN ('admin', 'superadmin'))` : `auth.jwt() ->> 'role' = '${role}'`,
-            comment: includeComments ? `${role} can ${action} records` : void 0
-          });
-        }
-      });
-    }
-  });
   return policies;
 }
 function generateChildEntityMigrations(parentEntityConfig, options) {

package/dist/lib/entities/pattern-usage-hooks.js

@@ -0,0 +1,96 @@
+import { getGlobalHooks } from "../plugins/hook-system.js";
+import { PatternUsageService } from "../services/pattern-usage.service.js";
+import { scheduleAction } from "../scheduled-actions/scheduler.js";
+import { entityRegistry } from "./registry.js";
+function hasBlocksColumn(entityName) {
+  var _a;
+  try {
+    const entityConfig = entityRegistry.get(entityName);
+    return ((_a = entityConfig == null ? void 0 : entityConfig.builder) == null ? void 0 : _a.enabled) === true;
+  } catch {
+    return false;
+  }
+}
+function extractBlocks(data) {
+  if (!data || !("blocks" in data)) return [];
+  const blocks = data.blocks;
+  if (!Array.isArray(blocks)) return [];
+  return blocks;
+}
+function initPatternUsageHooks() {
+  const hooks = getGlobalHooks();
+  hooks.addAction("entity.created", async (hookData) => {
+    const data = hookData;
+    const { entityName, data: entityData, userId } = data;
+    if (!hasBlocksColumn(entityName)) return;
+    if (entityName === "patterns") return;
+    const entity = entityData;
+    if (!(entity == null ? void 0 : entity.id) || !(entity == null ? void 0 : entity.teamId)) return;
+    const blocks = extractBlocks(entity);
+    if (blocks.length === 0) return;
+    await PatternUsageService.syncUsages(
+      entityName,
+      String(entity.id),
+      String(entity.teamId),
+      blocks,
+      userId || "system"
+    );
+  });
+  hooks.addAction("entity.updated", async (hookData) => {
+    const data = hookData;
+    const { entityName, data: entityData, userId } = data;
+    if (!hasBlocksColumn(entityName)) return;
+    if (entityName === "patterns") return;
+    const entity = entityData;
+    if (!(entity == null ? void 0 : entity.id) || !(entity == null ? void 0 : entity.teamId)) return;
+    const blocks = extractBlocks(entity);
+    await PatternUsageService.syncUsages(
+      entityName,
+      String(entity.id),
+      String(entity.teamId),
+      blocks,
+      userId || "system"
+    );
+  });
+  hooks.addAction("entity.deleted", async (hookData) => {
+    const data = hookData;
+    const { entityName, id, userId } = data;
+    if (!hasBlocksColumn(entityName)) return;
+    if (entityName === "patterns") return;
+    if (!id) return;
+    await PatternUsageService.removeEntityUsages(
+      entityName,
+      id,
+      userId || "system"
+    );
+  });
+  hooks.addAction("entity.patterns.updated", async (hookData) => {
+    const data = hookData;
+    const { id, userId, data: entityData } = data;
+    if (!id) return;
+    const teamId = entityData == null ? void 0 : entityData.teamId;
+    try {
+      await scheduleAction(
+        "pattern:invalidate-cache",
+        { patternId: id, userId: userId || "system" },
+        {
+          scheduledAt: /* @__PURE__ */ new Date(),
+          // Run immediately
+          teamId
+        }
+      );
+      console.info(`[PatternUsageHooks] Scheduled async cache invalidation for pattern ${id}`);
+    } catch (error) {
+      console.error(`[PatternUsageHooks] Error scheduling cache invalidation for pattern ${id}:`, error);
+    }
+  });
+  console.log("[PatternUsageHooks] Initialized pattern usage tracking and cache invalidation hooks");
+}
+function isPatternUsageHooksInitialized() {
+  const hooks = getGlobalHooks();
+  return hooks.hasHook("entity.created");
+}
+export {
+  initPatternUsageHooks,
+  isPatternUsageHooksInitialized
+};