@qikdev/sdk 0.1.212 → 0.1.214

package/package.json

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

package/src/api/qik.content.js

@@ -64,8 +64,160 @@ export default function (qik) {
   ///////////////////////////////////////////////////
 
   const glossaryCache = qik.cache.get("user:glossary");
+  const glossaryIndexCache = qik.cache.get("user:glossary:index");
+  const definitionCache = qik.cache.get("user:glossary:definitions");
 
   let inflightGlossaryRequest;
+  let inflightGlossaryIndexRequest;
+  let inflightDefinitionRequests = {};
+
+  /**
+   * 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 });
+   */
+  service.loadGlossaryIndex = async function (options) {
+    options = options || {};
+
+    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;
+      glossaryIndexCache.set("index", data);
+      cached = data;
+      qik.dispatch("glossary:index", data);
+    }
+
+    if (options.hash) {
+      return qik.utils.hash(cached, "key");
+    }
+
+    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.
+   * 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
+   * @param {Boolean} options.reload Force reload from server
+   * @returns {Promise<Object>} The full type definition
+   * @example
+   * const article = await sdk.content.getDefinition('article');
+   * console.log(article.fields);
+   */
+  service.getDefinition = async function (key, options) {
+    options = options || {};
+
+    // Return cached if available and not forcing reload
+    let cached = definitionCache.get(key);
+    if (cached && !options.reload && !options.refresh) {
+      return cached;
+    }
+
+    // If already loading, wait for it (request deduplication)
+    if (inflightDefinitionRequests[key]) {
+      await inflightDefinitionRequests[key];
+      return definitionCache.get(key);
+    }
+
+    // Make the request
+    inflightDefinitionRequests[key] = qik.api.get(`/glossary/index/${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 = {};
+
+  /**
+   * 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
+   * const submissions = await sdk.content.loadDefinitionsForType('submission');
+   * const workflowCards = await sdk.content.loadDefinitionsForType('workflowcard', { hash: true });
+   */
+  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;
+    }
+
+    // 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;
+    }
+  };
 
   /**
    * Inflate a single value from compressed format

package/src/version.js

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