@ductape/sdk 0.2.7 → 0.2.9

package/dist/index.js

@@ -503,7 +503,7 @@ class Ductape {
         }
     }
     constructor({ accessKey, redis_url, product, env, local, ip_address, language, runtime_sync }) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this.productBuilders = new Map();
         this.appBuilders = new Map();
         // Cached service instances (lazily initialized after auth)
@@ -531,6 +531,9 @@ class Ductape {
         this.runtimePollJitter = 0.2;
         this.runtimeMaxBackoffMs = 300000;
         this.runtimeWarmupEnabled = true;
+        this.runtimeWarmupConnectionTimeoutMs = 5000;
+        this.runtimeStrictReady = false;
+        this.runtimeDatabaseTags = [];
         this.runtimeCredentialState = { status: 'idle', referenced: 0, cached: 0, missing: 0 };
         this.runtimeClosed = false;
         /** Register and inspect portable application functions used by Feature JSON. */
@@ -5456,6 +5459,8 @@ class Ductape {
             this.runtimePollJitter = Math.max(0, Math.min(1, (_b = runtime_sync.jitter) !== null && _b !== void 0 ? _b : 0.2));
             this.runtimeMaxBackoffMs = Math.max(this.runtimePollIntervalMs, (_c = runtime_sync.max_backoff_ms) !== null && _c !== void 0 ? _c : 300000);
             this.runtimeWarmupEnabled = runtime_sync.warm_connections !== false;
+            this.runtimeWarmupConnectionTimeoutMs = Math.max(1000, (_d = runtime_sync.warm_connection_timeout_ms) !== null && _d !== void 0 ? _d : 5000);
+            this.runtimeStrictReady = runtime_sync.strict_ready === true;
         }
         // Services are lazily initialized via factory methods (createNewDatabaseService, etc.)
         // This ensures initUserAuth() is called before service creation
@@ -5806,7 +5811,12 @@ class Ductape {
         const scope = `${this.workspace_id}:${response.snapshot.product_tag}:${response.snapshot.env_slug}`;
         (0, bootstrap_cache_1.primeRuntimeBootstrapCache)(this.workspace_id, scope, response.snapshot.entries);
         this.runtimeManifest = response.manifest;
-        this.runtimeCredentialBundle = (_a = response.snapshot.credentials) !== null && _a !== void 0 ? _a : { referenced_keys: [], encrypted_secrets: [] };
+        const derivedReferences = (0, secrets_1.findAllSecretReferences)(response.snapshot.entries.map((entry) => entry.data)).sort();
+        this.runtimeCredentialBundle = response.snapshot.credentials
+            ? Object.assign(Object.assign({}, response.snapshot.credentials), { referenced_keys: [...new Set([
+                        ...((_a = response.snapshot.credentials.referenced_keys) !== null && _a !== void 0 ? _a : []),
+                        ...derivedReferences,
+                    ])].sort() }) : { referenced_keys: derivedReferences, encrypted_secrets: [] };
         const referenced = (_c = (_b = this.runtimeCredentialBundle.referenced_keys) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : this.runtimeCredentialBundle.encrypted_secrets.length;
         const cached = this.runtimeCredentialBundle.encrypted_secrets.length;
         this.runtimeCredentialState = {
@@ -5862,6 +5872,7 @@ class Ductape {
                 .filter((entry) => (entry === null || entry === void 0 ? void 0 : entry.domain) === 'database')
                 .map((entry) => { var _a, _b, _c; return String(((_a = entry === null || entry === void 0 ? void 0 : entry.parts) === null || _a === void 0 ? void 0 : _a[2]) || ((_c = (_b = entry === null || entry === void 0 ? void 0 : entry.data) === null || _b === void 0 ? void 0 : _b.database) === null || _c === void 0 ? void 0 : _c.tag) || '').trim(); })
                 .filter(Boolean))];
+        this.runtimeDatabaseTags = databaseTags;
         this.startRuntimeWarmup(databaseTags, Boolean(previousManifest && previousManifest.connectionRevision !== response.manifest.connectionRevision));
     }
     startRuntimeWarmup(databaseTags, recycleConnections) {
@@ -5878,7 +5889,10 @@ class Ductape {
             const databases = await Promise.all(databaseTags.map(async (tag) => {
                 const start = Date.now();
                 try {
-                    await service.connect({ product: this.defaultProduct, env: this.defaultEnv, database: tag });
+                    await service.connect({
+                        product: this.defaultProduct, env: this.defaultEnv, database: tag,
+                        options: { connectionTimeout: this.runtimeWarmupConnectionTimeoutMs },
+                    });
                     return { tag, status: 'ready', durationMs: Date.now() - start };
                 }
                 catch (error) {
@@ -5916,7 +5930,7 @@ class Ductape {
         (_b = (_a = this.runtimePollTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
     }
     async pollRuntimeManifest(failureCount) {
-        var _a, _b;
+        var _a, _b, _c;
         if (!this.defaultProduct || !this.defaultEnv || this.runtimeClosed)
             return;
         try {
@@ -5931,6 +5945,9 @@ class Ductape {
             }
             else if (this.defaultProduct && this.defaultEnv) {
                 (0, bootstrap_cache_1.touchRuntimeBootstrapCache)(`${this.workspace_id}:${this.defaultProduct}:${this.defaultEnv}`);
+                if ((_c = this.runtimeWarmupState) === null || _c === void 0 ? void 0 : _c.databases.some((database) => database.status === 'failed')) {
+                    this.startRuntimeWarmup(this.runtimeDatabaseTags, false);
+                }
             }
             this.runtimeLastError = undefined;
             this.scheduleRuntimePoll(0);
@@ -5951,7 +5968,7 @@ class Ductape {
             if (response) {
                 this.applyRuntimeSnapshot(response);
                 const secrets = await this.createNewSecretsService();
-                this.applyRuntimeCredentialBundle(secrets);
+                await this.prepareRuntimeCredentials(secrets);
             }
             this.scheduleRuntimePoll(0);
         })().finally(() => { this.runtimeRefreshInFlight = undefined; });
@@ -5972,7 +5989,7 @@ class Ductape {
     }
     assertRuntimeReady() {
         var _a, _b;
-        if (!this.runtimeSyncEnabled)
+        if (!this.runtimeSyncEnabled || !this.runtimeStrictReady)
             return;
         if (this.runtimeCredentialState.status === 'incomplete') {
             throw new Error(`Runtime credentials are incomplete (${this.runtimeCredentialState.missing} referenced secret(s) unavailable)`);
@@ -6299,6 +6316,27 @@ class Ductape {
             throw error;
         }
     }
+    async prepareRuntimeCredentials(service) {
+        var _a, _b;
+        this.applyRuntimeCredentialBundle(service);
+        if (!this.runtimeCredentialBundle)
+            return;
+        const bundled = new Set(this.runtimeCredentialBundle.encrypted_secrets.map((secret) => secret.key));
+        const missingKeys = ((_a = this.runtimeCredentialBundle.referenced_keys) !== null && _a !== void 0 ? _a : []).filter((key) => !bundled.has(key));
+        if (!missingKeys.length)
+            return;
+        this.runtimeCredentialState = Object.assign(Object.assign({}, this.runtimeCredentialState), { status: 'loading', missing: missingKeys.length });
+        const results = await Promise.allSettled(missingKeys.map((key) => service.fetch(key)));
+        const failed = results.filter((result) => result.status === 'rejected').length;
+        const cached = bundled.size + results.length - failed;
+        this.runtimeCredentialState = {
+            status: failed ? 'incomplete' : 'ready',
+            referenced: ((_b = this.runtimeCredentialBundle.referenced_keys) !== null && _b !== void 0 ? _b : []).length,
+            cached,
+            missing: failed,
+            refreshedAt: Date.now(),
+        };
+    }
     async createNewCloudService() {
         const subCheck = false;
         if (!this.token || !this.public_key) {