@ductape/sdk 0.1.117 → 0.1.120

package/dist/products/services/products.service.js

@@ -5120,16 +5120,47 @@ class ProductsBuilderService {
                         }
                     }
                 }
-                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+                try {
+                    await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+                }
+                catch (createErr) {
+                    // The by-tag existence check above (fetchFeature) is known to false-negative
+                    // under backend read lag -- confirmed by tags that unambiguously already exist
+                    // (verified via the always-consistent list-all endpoint) still failing this
+                    // check, especially under the ~30-way concurrent defineFeature() calls this SDK
+                    // makes on a typical app boot. If the backend now rejects this as a duplicate,
+                    // the feature was there all along and this is that false negative resolving
+                    // itself -- fall through to the read-back below instead of failing the caller.
+                    const isDuplicate = createErr instanceof Error && /already exists|duplicate|in use/i.test(createErr.message);
+                    if (!isDuplicate)
+                        throw createErr;
+                }
                 // A successful mutation response is insufficient: execution and Workbench
                 // use the catalogue read API. Confirm that exact path can observe the write.
-                for (let attempt = 0; attempt < 5; attempt += 1) {
+                // Widened from the original 5x50-200ms budget (~500ms total): that was proven
+                // too tight against real backend read lag, which is on the order of seconds
+                // under concurrent boot-time load, not milliseconds.
+                let delay = 100;
+                for (let attempt = 0; attempt < 8; attempt += 1) {
                     const persisted = await this.fetchFeature(data.tag);
                     if (persisted)
                         return persisted;
-                    if (attempt < 4)
-                        await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+                    if (attempt < 7) {
+                        await new Promise((resolve) => setTimeout(resolve, delay));
+                        delay = Math.min(delay * 2, 3000);
+                    }
                 }
+                // The by-tag read path is still lagging. Fall back to the list-all endpoint,
+                // which every observed case shows is immediately consistent -- if the feature
+                // shows up there, the write is real and the by-tag path is just slow, so don't
+                // fail the caller (e.g. a boot-time feature registration) over that.
+                const all = await this.fetchFeatures();
+                const viaList = all.find((feature) => feature.tag === data.tag);
+                if (viaList)
+                    return viaList;
+                // Genuinely unconfirmed on every read path we have, including the always-reliable
+                // list-all endpoint -- this is no longer just a lagging read, so fail loudly
+                // instead of pretending the write succeeded.
                 throw new Error(`Feature catalogue write was acknowledged but ${data.tag} could not be read back`);
             }
             else {
@@ -5169,11 +5200,35 @@ class ProductsBuilderService {
     }
     async fetchFeatures() {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'feature', this.getUserAccess());
-        return components;
+        if (Array.isArray(components) && components.length > 0) {
+            return components;
+        }
+        // Compatibility path for rolling backend deployments. The full-product
+        // endpoint and Workbench read the canonical embedded `features` array,
+        // while older /components/:id/feature handlers can incorrectly return an
+        // empty list. Always perform a fresh product read before concluding that a
+        // product has no features.
+        const product = await this.productApi.fetchProduct(this.product_id, this.getUserAccess());
+        const rawProduct = product;
+        const byTag = new Map();
+        for (const feature of [
+            ...(rawProduct.features || []),
+            ...(rawProduct.workflows || []),
+        ]) {
+            if ((feature === null || feature === void 0 ? void 0 : feature.tag) && feature.deleted !== true && !byTag.has(feature.tag)) {
+                byTag.set(feature.tag, feature);
+            }
+        }
+        return Array.from(byTag.values());
     }
     async fetchFeature(tag) {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'feature', tag, this.getUserAccess());
-        return component;
+        if (component)
+            return component;
+        // Keep tag lookup consistent with fetchFeatures()/Workbench when an older
+        // feature-component endpoint is still serving traffic.
+        const features = await this.fetchFeatures();
+        return features.find((feature) => feature.tag === tag) || null;
     }
     async deleteFeature(tag) {
         try {