@qikdev/sdk 0.1.213 → 0.1.214

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qikdev/sdk",
-  "version": "0.1.213",
+  "version": "0.1.214",
   "type": "module",
   "description": "Promise based Javascript SDK",
   "main": "./dist/main.js",

package/src/api/qik.content.js

@@ -70,79 +70,60 @@ export default function (qik) {
   let inflightGlossaryRequest;
   let inflightGlossaryIndexRequest;
   let inflightDefinitionRequests = {};
-  let indexItemsByKey = {};
-  let hydrationQueue = [];
-  let isHydrating = false;
-
-  const CONCURRENT_HYDRATION_REQUESTS = 3;
 
   /**
-   * Start background hydration of all definitions
-   * Uses concurrent workers for faster loading
-   * @private
+   * Load the lightweight glossary index.
+   * Returns cached version unless reload is specified.
+   * @alias content.loadGlossaryIndex
+   * @param {Object} options Additional options
+   * @param {Boolean} options.hash Return as object keyed by type key
+   * @param {Boolean} options.hex Return as object keyed by hex
+   * @param {Boolean} options.reload Force reload from server
+   * @returns {Promise<Array|Object>} The glossary index
+   * @example
+   * const index = await sdk.content.loadGlossaryIndex();
+   * const indexHash = await sdk.content.loadGlossaryIndex({ hash: true });
    */
-  async function startBackgroundHydration(keys) {
-    hydrationQueue = [...keys];
-    if (isHydrating) return;
-    isHydrating = true;
-
-    // Worker function that pulls from the shared queue
-    async function worker() {
-      while (hydrationQueue.length > 0) {
-        const key = hydrationQueue.shift();
-
-        // Skip if already populated or loading
-        if (indexItemsByKey[key]?.populated) continue;
-        if (inflightDefinitionRequests[key]) continue;
-
-        try {
-          await loadDefinition(key);
-        } catch (e) {
-          console.warn(`Failed to hydrate ${key}:`, e);
-        }
-      }
-    }
-
-    // Start concurrent workers
-    const workers = [];
-    for (let i = 0; i < CONCURRENT_HYDRATION_REQUESTS; i++) {
-      workers.push(worker());
-    }
-    await Promise.all(workers);
+  service.loadGlossaryIndex = async function (options) {
+    options = options || {};
 
-    isHydrating = false;
-  }
+    let cached = glossaryIndexCache.get("index");
+    const reload = options.reload || options.refresh || !cached;
 
-  /**
-   * Load a single definition from the server
-   * @private
-   */
-  async function loadDefinition(key) {
-    inflightDefinitionRequests[key] = qik.api.get(`/glossary/${key}`);
+    if (reload) {
+      if (!inflightGlossaryIndexRequest) {
+        inflightGlossaryIndexRequest = qik.api.get("/glossary/index");
+        inflightGlossaryIndexRequest.then(
+          () => {
+            inflightGlossaryIndexRequest = null;
+          },
+          () => {
+            inflightGlossaryIndexRequest = null;
+          },
+        );
+      }
 
-    try {
-      const { data } = await inflightDefinitionRequests[key];
+      const { data } = await inflightGlossaryIndexRequest;
+      glossaryIndexCache.set("index", data);
+      cached = data;
+      qik.dispatch("glossary:index", data);
+    }
 
-      // Merge full data into existing index item (mutate in place)
-      const indexItem = indexItemsByKey[key];
-      if (indexItem) {
-        Object.assign(indexItem, data, { populated: true });
-      }
+    if (options.hash) {
+      return qik.utils.hash(cached, "key");
+    }
 
-      // Also cache separately for getDefinition()
-      const cached = indexItem || { ...data, populated: true };
-      definitionCache.set(key, cached);
-      qik.dispatch("glossary:definition", { key, data: cached });
-      return cached;
-    } finally {
-      inflightDefinitionRequests[key] = null;
+    if (options.hex) {
+      return qik.utils.hash(cached, "hex");
     }
-  }
+
+    return cached;
+  };
 
   /**
    * Get a full definition for a specific type.
    * Returns cached if available, otherwise fetches from server.
-   * If background hydration is in progress, prioritizes this key.
+   * Multiple simultaneous calls for the same key share one request.
    * @alias content.getDefinition
    * @param {String} key The type key (e.g., 'article', 'profile')
    * @param {Object} options Additional options
@@ -161,43 +142,81 @@ export default function (qik) {
       return cached;
     }
 
-    // If already loading, wait for it
+    // If already loading, wait for it (request deduplication)
     if (inflightDefinitionRequests[key]) {
       await inflightDefinitionRequests[key];
       return definitionCache.get(key);
     }
 
-    // Prioritize: move to front of queue
-    const queueIndex = hydrationQueue.indexOf(key);
-    if (queueIndex > 0) {
-      hydrationQueue.splice(queueIndex, 1);
-      hydrationQueue.unshift(key);
-    }
+    // Make the request
+    inflightDefinitionRequests[key] = qik.api.get(`/glossary/index/${key}`);
 
-    // Load it now
-    return loadDefinition(key);
+    try {
+      const { data } = await inflightDefinitionRequests[key];
+      definitionCache.set(key, data);
+      qik.dispatch("glossary:definition", { key, data });
+      return data;
+    } finally {
+      inflightDefinitionRequests[key] = null;
+    }
   };
 
+  let inflightTypeRequests = {};
+  let typeResultsCache = {};
+
   /**
-   * Start loading all remaining definitions in the background.
-   * Requires glossary({ index: true }) to be called first.
-   * Uses concurrent requests for faster loading.
-   * @alias content.hydrateInBackground
+   * Load all definitions that match or extend a given type.
+   * For example, loadDefinitionsForType('submission') returns all form definitions.
+   * Results are cached individually - subsequent getDefinition() calls return from cache.
+   * @alias content.loadDefinitionsForType
+   * @param {String} type The base type key (e.g., 'submission', 'workflowcard', 'article')
+   * @param {Object} options Additional options
+   * @param {Boolean} options.hash Return as object keyed by definition key
+   * @param {Boolean} options.reload Force reload from server
+   * @returns {Promise<Array|Object>} Array of definitions, or hash if options.hash
    * @example
-   * await sdk.content.glossary({ index: true });
-   * sdk.content.hydrateInBackground();
+   * const submissions = await sdk.content.loadDefinitionsForType('submission');
+   * const workflowCards = await sdk.content.loadDefinitionsForType('workflowcard', { hash: true });
    */
-  service.hydrateInBackground = function () {
-    const cached = glossaryIndexCache.get("index");
-    if (!cached) {
-      console.warn(
-        "Call glossary({ index: true }) before hydrateInBackground()",
-      );
-      return;
+  service.loadDefinitionsForType = async function (type, options) {
+    options = options || {};
+
+    // Return cached if available and not forcing reload
+    if (typeResultsCache[type] && !options.reload && !options.refresh) {
+      const data = typeResultsCache[type];
+      return options.hash ? qik.utils.hash(data, "key") : data;
+    }
+
+    // If already loading this type, wait for it
+    if (inflightTypeRequests[type]) {
+      await inflightTypeRequests[type];
+      const data = typeResultsCache[type];
+      return options.hash ? qik.utils.hash(data, "key") : data;
     }
 
-    const keys = cached.map((item) => item.key);
-    startBackgroundHydration(keys);
+    // Make the request
+    inflightTypeRequests[type] = qik.api.get(`/glossary/index/${type}/all`);
+
+    try {
+      const { data } = await inflightTypeRequests[type];
+
+      // Cache the type results for subsequent calls
+      typeResultsCache[type] = data;
+
+      // Cache each definition individually in the unified cache
+      data.forEach((definition) => {
+        definitionCache.set(definition.key, definition);
+      });
+
+      qik.dispatch("glossary:type", { type, definitions: data });
+
+      if (options.hash) {
+        return qik.utils.hash(data, "key");
+      }
+      return data;
+    } finally {
+      inflightTypeRequests[type] = null;
+    }
   };
 
   /**
@@ -336,62 +355,15 @@ export default function (qik) {
      * @param  {Boolean} options.reload Force glossary to reload and not be cached.
       If false will retrieve content type data from the in memory cache
      * @param  {Boolean} options.uncompressed Use the uncompressed endpoint
-     * @param  {Boolean} options.index Use lightweight index mode with background hydration
      * @example
      *
      * const { article, profile } = await sdk.content.glossary({hash:true});
      * // Use compressed endpoint for faster loading
      * const glossary = await sdk.content.glossary({compressed:true});
-     * // Use lightweight index with background hydration
-     * const glossary = await sdk.content.glossary({index:true, hash:true});
      */
   service.glossary = async function (options) {
     options = options || {};
 
-    // Index mode: lightweight load with background hydration
-    if (options.index) {
-      let cached = glossaryIndexCache.get("index");
-      const reload = options.reload || options.refresh || !cached;
-
-      if (reload) {
-        if (!inflightGlossaryIndexRequest) {
-          inflightGlossaryIndexRequest = qik.api.get("/glossary/index");
-          inflightGlossaryIndexRequest.then(
-            () => {
-              inflightGlossaryIndexRequest = null;
-            },
-            () => {
-              inflightGlossaryIndexRequest = null;
-            },
-          );
-        }
-
-        const { data } = await inflightGlossaryIndexRequest;
-
-        // Add populated:false to each item and build lookup map
-        data.forEach((item) => {
-          item.populated = false;
-          indexItemsByKey[item.key] = item;
-        });
-
-        glossaryIndexCache.set("index", data);
-        cached = data;
-        qik.dispatch("glossary:index", data);
-        // No auto-hydration - call hydrateInBackground() explicitly if needed
-      }
-
-      if (options.hash) {
-        return qik.utils.hash(cached, "key");
-      }
-
-      if (options.hex) {
-        return qik.utils.hash(cached, "hex");
-      }
-
-      return cached;
-    }
-
-    // Full glossary mode (existing behavior)
     // Check if we already have the glossary cached
     let cached = glossaryCache.get("glossary");
     const uncompressed = !!options.uncompressed;

package/src/version.js

@@ -1 +1 @@
-export const version = "0.1.213";
+export const version = "0.1.214";