@trops/dash-core 0.1.15 → 0.1.17

package/dist/electron/index.js

@@ -4135,7 +4135,7 @@ const {
 const appName$2 = "Dashboard";
 const configFilename$2 = "providers.json";
 
-const providerController$1 = {
+const providerController$2 = {
   /**
    * saveProvider
    * Save a new provider with encrypted credentials
@@ -4395,7 +4395,7 @@ const providerController$1 = {
   },
 };
 
-var providerController_1 = providerController$1;
+var providerController_1 = providerController$2;
 
 const { app: app$2 } = require$$0;
 const path$7 = require$$1$1;
@@ -5954,6 +5954,216 @@ const pluginController$1 = {
 
 var pluginController_1 = pluginController$1;
 
+/**
+ * clientCache
+ *
+ * Generic provider client cache for the main process.
+ * Caches API clients (e.g., algoliasearch, Stripe) by provider hash.
+ * Factories are registered per provider type; credentials are resolved
+ * from the encrypted store — renderer never sends credential fields.
+ */
+
+const providerController$1 = providerController_1;
+
+const clients = new Map(); // hash → client
+const factories = new Map(); // providerType → factoryFn(credentials)
+const pendingClients = new Map(); // hash → Promise (dedup in-flight)
+const providerLookup = new Map(); // "appId:providerName" → hash (reverse lookup)
+
+const clientCache$1 = {
+    registerFactory(providerType, factoryFn) {
+        factories.set(providerType, factoryFn);
+    },
+
+    async getClient(providerHash, appId, providerName) {
+        // Cache hit
+        if (clients.has(providerHash)) {
+            return clients.get(providerHash);
+        }
+
+        // Dedup in-flight (same pattern as mcpController.pendingStarts)
+        if (pendingClients.has(providerHash)) {
+            return pendingClients.get(providerHash);
+        }
+
+        const promise = this._resolve(providerHash, appId, providerName);
+        pendingClients.set(providerHash, promise);
+        try {
+            return await promise;
+        } finally {
+            pendingClients.delete(providerHash);
+        }
+    },
+
+    async _resolve(providerHash, appId, providerName) {
+        const result = providerController$1.getProvider(null, appId, providerName);
+        if (result.error) throw new Error(result.message);
+
+        const { provider } = result;
+        const factory = factories.get(provider.type);
+        if (!factory) {
+            throw new Error(`No client factory for type: ${provider.type}`);
+        }
+
+        const client = factory(provider.credentials);
+        clients.set(providerHash, client);
+        providerLookup.set(`${appId}:${providerName}`, providerHash);
+        console.log(
+            `[clientCache] Created ${provider.type} client (hash: ${providerHash.slice(0, 8)}...)`
+        );
+        return client;
+    },
+
+    invalidate(appId, providerName) {
+        const lookupKey = `${appId}:${providerName}`;
+        const hash = providerLookup.get(lookupKey);
+        if (hash) {
+            clients.delete(hash);
+            providerLookup.delete(lookupKey);
+            console.log(
+                `[clientCache] Invalidated ${providerName} (hash: ${hash.slice(0, 8)}...)`
+            );
+        }
+    },
+
+    invalidateAll() {
+        const count = clients.size;
+        clients.clear();
+        providerLookup.clear();
+        pendingClients.clear();
+        console.log(
+            `[clientCache] Invalidated all (${count} clients cleared)`
+        );
+    },
+
+    clear() {
+        clients.clear();
+        providerLookup.clear();
+        pendingClients.clear();
+    },
+};
+
+var clientCache_1 = clientCache$1;
+
+/**
+ * responseCache.js
+ *
+ * TTL-based API response cache with in-flight deduplication.
+ * Renderer-driven: widget developer includes { cache: true } or { cache: { ttl: N } }
+ * in IPC messages to opt-in to caching per call.
+ *
+ * Usage:
+ *   // Wrap a handler:
+ *   ipcMain.handle("my-channel", responseCache.cachedHandler("my-channel", handler));
+ *
+ *   // Widget-side (renderer):
+ *   window.mainApi.myService.getData({ ...pc, cache: true });              // 30s default
+ *   window.mainApi.myService.getData({ ...pc, cache: 60000 });             // 60s
+ *   window.mainApi.myService.getData({ ...pc, cache: { ttl: 120000 } });   // 120s
+ *   window.mainApi.myService.getData({ ...pc, cache: true, forceRefresh: true }); // bypass
+ */
+
+const cache = new Map(); // key → { data, timestamp, ttl }
+const inflight = new Map(); // key → Promise
+
+function stableHash(obj) {
+    const str = JSON.stringify(obj, Object.keys(obj).sort());
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xffffffff;
+    }
+    return hash.toString(36);
+}
+
+const responseCache$1 = {
+    async get(key, fetcher, options = {}) {
+        const { ttl = 30000, forceRefresh = false } = options;
+
+        if (!forceRefresh && cache.has(key)) {
+            const entry = cache.get(key);
+            if (Date.now() - entry.timestamp < entry.ttl) {
+                console.log(`[responseCache] HIT ${key}`);
+                return entry.data;
+            }
+            cache.delete(key);
+        }
+
+        if (!forceRefresh && inflight.has(key)) {
+            console.log(`[responseCache] DEDUP ${key}`);
+            return inflight.get(key);
+        }
+
+        console.log(`[responseCache] MISS ${key}`);
+        const promise = fetcher();
+        inflight.set(key, promise);
+        try {
+            const data = await promise;
+            if (data && !data.error) {
+                cache.set(key, { data, timestamp: Date.now(), ttl });
+            }
+            return data;
+        } finally {
+            inflight.delete(key);
+        }
+    },
+
+    /**
+     * Wrap an ipcMain.handle handler with renderer-driven caching.
+     * If the incoming message has a `cache` property, the response is cached.
+     * If the message has `forceRefresh: true`, the cache is bypassed.
+     *
+     * The `cache` and `forceRefresh` properties are stripped from the message
+     * before passing to the handler, so handlers receive clean params.
+     *
+     * Cache parameter forms:
+     *   cache: true         → 30s default TTL
+     *   cache: 60000        → 60s (number shorthand)
+     *   cache: { ttl: N }   → explicit TTL in ms
+     */
+    cachedHandler(channelName, handler) {
+        return async (e, msg) => {
+            const { cache: cacheOpt, forceRefresh, ...params } = msg || {};
+            if (cacheOpt) {
+                const ttl =
+                    typeof cacheOpt === "number"
+                        ? cacheOpt
+                        : cacheOpt?.ttl || 30000;
+                const key = `${channelName}:${stableHash(params)}`;
+                return this.get(key, () => handler(e, params), {
+                    ttl,
+                    forceRefresh,
+                });
+            }
+            return handler(e, msg);
+        };
+    },
+
+    invalidate(key) {
+        cache.delete(key);
+    },
+
+    invalidatePrefix(prefix) {
+        for (const k of cache.keys()) {
+            if (k.startsWith(prefix)) cache.delete(k);
+        }
+    },
+
+    clear() {
+        cache.clear();
+        inflight.clear();
+    },
+
+    stats() {
+        return {
+            entries: cache.size,
+            inflight: inflight.size,
+            keys: [...cache.keys()],
+        };
+    },
+};
+
+var responseCache_1 = responseCache$1;
+
 /**
  * Controller exports.
  */
@@ -8634,6 +8844,10 @@ const openaiController = openaiController_1;
 const menuItemsController = menuItemsController_1;
 const pluginController = pluginController_1;
 
+// --- Utils ---
+const clientCache = clientCache_1;
+const responseCache = responseCache_1;
+
 // --- Controller functions (flat, for convenient destructuring) ---
 const controllers = controller;
 
@@ -8713,6 +8927,10 @@ var electron = {
   // Factory
   createMainApi,
   defaultMainApi,
+
+  // Utils
+  clientCache,
+  responseCache,
 };
 
 var index = /*@__PURE__*/getDefaultExportFromCjs(electron);