@ductape/sdk 0.2.5 → 0.2.7

package/dist/index.js

@@ -530,6 +530,8 @@ class Ductape {
         this.runtimePollIntervalMs = 30000;
         this.runtimePollJitter = 0.2;
         this.runtimeMaxBackoffMs = 300000;
+        this.runtimeWarmupEnabled = true;
+        this.runtimeCredentialState = { status: 'idle', referenced: 0, cached: 0, missing: 0 };
         this.runtimeClosed = false;
         /** Register and inspect portable application functions used by Feature JSON. */
         this.functions = {
@@ -5453,6 +5455,7 @@ class Ductape {
             this.runtimePollIntervalMs = Math.max(5000, (_a = runtime_sync.interval_ms) !== null && _a !== void 0 ? _a : 30000);
             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;
         }
         // Services are lazily initialized via factory methods (createNewDatabaseService, etc.)
         // This ensures initUserAuth() is called before service creation
@@ -5796,21 +5799,31 @@ class Ductape {
         };
     }
     applyRuntimeSnapshot(response) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         if (!(response === null || response === void 0 ? void 0 : response.snapshot))
             return;
+        const previousManifest = this.runtimeManifest;
         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 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 = {
+            status: 'loading', referenced, cached, missing: Math.max(0, referenced - cached),
+        };
+        if (this._secretsService)
+            this.applyRuntimeCredentialBundle(this._secretsService);
         const runtimeCredentials = new Map();
         for (const entry of response.snapshot.entries) {
             if ((entry === null || entry === void 0 ? void 0 : entry.domain) !== 'action')
                 continue;
-            const app = String(((_a = entry.parts) === null || _a === void 0 ? void 0 : _a[1]) || '');
-            const mapping = (_b = entry.data) === null || _b === void 0 ? void 0 : _b.product_env_mapping;
+            const app = String(((_d = entry.parts) === null || _d === void 0 ? void 0 : _d[1]) || '');
+            const mapping = (_e = entry.data) === null || _e === void 0 ? void 0 : _e.product_env_mapping;
             if (!app || !mapping)
                 continue;
-            const credentials = (_c = runtimeCredentials.get(app)) !== null && _c !== void 0 ? _c : {};
-            for (const variable of (_d = mapping.variables) !== null && _d !== void 0 ? _d : []) {
+            const credentials = (_f = runtimeCredentials.get(app)) !== null && _f !== void 0 ? _f : {};
+            for (const variable of (_g = mapping.variables) !== null && _g !== void 0 ? _g : []) {
                 if ((variable === null || variable === void 0 ? void 0 : variable.key) && variable.value !== undefined)
                     credentials[String(variable.key)] = variable.value;
             }
@@ -5819,13 +5832,13 @@ class Ductape {
             }
             // token_access data is the reusable request credential itself. credential_access
             // data contains login secrets and must only be sent to its dedicated auth action.
-            if (((_f = (_e = entry.data) === null || _e === void 0 ? void 0 : _e.app_auth) === null || _f === void 0 ? void 0 : _f.setup_type) === 'token_access' && ((_g = mapping.auth) === null || _g === void 0 ? void 0 : _g.data)) {
+            if (((_j = (_h = entry.data) === null || _h === void 0 ? void 0 : _h.app_auth) === null || _j === void 0 ? void 0 : _j.setup_type) === 'token_access' && ((_k = mapping.auth) === null || _k === void 0 ? void 0 : _k.data)) {
                 let authData = mapping.auth.data;
                 if (typeof authData === 'string') {
                     try {
                         authData = JSON.parse((0, processor_utils_1.decrypt)(authData, String(entry.data.private_key)));
                     }
-                    catch (_h) {
+                    catch (_l) {
                         authData = undefined;
                     }
                 }
@@ -5843,9 +5856,51 @@ class Ductape {
             runtimeCredentials.set(app, credentials);
         }
         credential_manager_1.credentialManager.replaceRuntimeScope(response.snapshot.product_tag, response.snapshot.env_slug, [...runtimeCredentials].map(([app, credentials]) => ({ app, credentials })));
-        this.runtimeManifest = response.manifest;
         this.runtimeLastRefreshAt = Date.now();
         this.runtimeLastError = undefined;
+        const databaseTags = [...new Set(response.snapshot.entries
+                .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.startRuntimeWarmup(databaseTags, Boolean(previousManifest && previousManifest.connectionRevision !== response.manifest.connectionRevision));
+    }
+    startRuntimeWarmup(databaseTags, recycleConnections) {
+        var _a, _b;
+        if (!this.runtimeWarmupEnabled || this.runtimeClosed || !this.defaultProduct || !this.defaultEnv || !databaseTags.length)
+            return;
+        const previous = (_b = (_a = this.runtimeWarmupInFlight) === null || _a === void 0 ? void 0 : _a.catch(() => undefined)) !== null && _b !== void 0 ? _b : Promise.resolve();
+        const warmup = previous.then(async () => {
+            const startedAt = Date.now();
+            this.runtimeWarmupState = { startedAt, databases: [] };
+            const service = await this.createNewDatabaseService();
+            if (recycleConnections)
+                await service.closeAll();
+            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 });
+                    return { tag, status: 'ready', durationMs: Date.now() - start };
+                }
+                catch (error) {
+                    return {
+                        tag,
+                        status: 'failed',
+                        durationMs: Date.now() - start,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }));
+            const completedAt = Date.now();
+            this.runtimeWarmupState = { startedAt, completedAt, durationMs: completedAt - startedAt, databases };
+        });
+        this.runtimeWarmupInFlight = warmup;
+        warmup.finally(() => {
+            if (this.runtimeWarmupInFlight === warmup)
+                this.runtimeWarmupInFlight = undefined;
+        }).catch(() => undefined);
+        warmup.catch((error) => {
+            this.runtimeLastError = `Runtime connection warm-up failed: ${error instanceof Error ? error.message : String(error)}`;
+        });
     }
     scheduleRuntimePoll(failureCount = 0) {
         var _a, _b;
@@ -5893,8 +5948,11 @@ class Ductape {
         this.runtimeRefreshInFlight = (async () => {
             var _a;
             const response = await this.productsApi.bootstrapRuntime(Object.assign({ product_tag: this.defaultProduct, env_slug: this.defaultEnv }, (force ? {} : { etag: (_a = this.runtimeManifest) === null || _a === void 0 ? void 0 : _a.runtimeRevision })), this.runtimeAuth());
-            if (response)
+            if (response) {
                 this.applyRuntimeSnapshot(response);
+                const secrets = await this.createNewSecretsService();
+                this.applyRuntimeCredentialBundle(secrets);
+            }
             this.scheduleRuntimePoll(0);
         })().finally(() => { this.runtimeRefreshInFlight = undefined; });
         return await this.runtimeRefreshInFlight;
@@ -5902,14 +5960,34 @@ class Ductape {
     /** Force a full product runtime refresh and atomically replace bootstrap cache entries. */
     async ready() {
         await this.initUserAuth(false);
+        await this.runtimeWarmupInFlight;
+        this.assertRuntimeReady();
     }
     /** Force a full product runtime refresh and atomically replace bootstrap cache entries. */
     async refreshRuntime() {
         await this.initUserAuth(false);
         await this.refreshRuntimeSnapshot(true);
+        await this.runtimeWarmupInFlight;
+        this.assertRuntimeReady();
+    }
+    assertRuntimeReady() {
+        var _a, _b;
+        if (!this.runtimeSyncEnabled)
+            return;
+        if (this.runtimeCredentialState.status === 'incomplete') {
+            throw new Error(`Runtime credentials are incomplete (${this.runtimeCredentialState.missing} referenced secret(s) unavailable)`);
+        }
+        if (this.runtimeCredentialState.status === 'failed') {
+            throw new Error(`Runtime credential preparation failed: ${this.runtimeCredentialState.error || 'unknown error'}`);
+        }
+        const failedConnections = (_b = (_a = this.runtimeWarmupState) === null || _a === void 0 ? void 0 : _a.databases.filter((database) => database.status === 'failed')) !== null && _b !== void 0 ? _b : [];
+        if (this.runtimeWarmupEnabled && failedConnections.length) {
+            throw new Error(`Runtime connection warm-up failed for: ${failedConnections.map((database) => database.tag).join(', ')}`);
+        }
     }
     /** Observe the local product runtime snapshot without exposing cached configuration or secrets. */
     runtimeSnapshotStatus() {
+        var _a;
         return {
             enabled: this.runtimeSyncEnabled,
             product: this.defaultProduct,
@@ -5918,16 +5996,28 @@ class Ductape {
             lastRefreshAt: this.runtimeLastRefreshAt,
             lastError: this.runtimeLastError,
             refreshing: Boolean(this.runtimeRefreshInFlight),
+            readiness: {
+                configuration: this.runtimeManifest ? 'ready' : 'loading',
+                credentials: Object.assign({}, this.runtimeCredentialState),
+                connections: this.runtimeWarmupInFlight
+                    ? 'warming'
+                    : ((_a = this.runtimeWarmupState) === null || _a === void 0 ? void 0 : _a.databases.some((database) => database.status === 'failed'))
+                        ? 'degraded'
+                        : 'ready',
+            },
+            warmup: this.runtimeWarmupState ? Object.assign(Object.assign({}, this.runtimeWarmupState), { databases: this.runtimeWarmupState.databases.map((database) => (Object.assign({}, database))), warming: Boolean(this.runtimeWarmupInFlight) }) : { warming: Boolean(this.runtimeWarmupInFlight), databases: [] },
         };
     }
     /** Stop background synchronization and release SDK-owned background resources. */
     async close() {
-        var _a;
+        var _a, _b, _c;
         this.runtimeClosed = true;
         if (this.runtimePollTimer)
             clearTimeout(this.runtimePollTimer);
         this.runtimePollTimer = undefined;
         await ((_a = this.runtimeRefreshInFlight) === null || _a === void 0 ? void 0 : _a.catch(() => undefined));
+        await ((_b = this.runtimeWarmupInFlight) === null || _b === void 0 ? void 0 : _b.catch(() => undefined));
+        await ((_c = this._databaseService) === null || _c === void 0 ? void 0 : _c.closeAll().catch(() => undefined));
         const resources = [this.jobsWorker, this.healthCheckWorker, this.healthCheckUpdaterWorker,
             this.jobsQueue, this.healthCheckQueue, this.healthCheckUpdaterQueue];
         await Promise.all(resources.filter(Boolean).map((resource) => { var _a; return Promise.resolve((_a = resource.close) === null || _a === void 0 ? void 0 : _a.call(resource)).catch(() => undefined); }));
@@ -5935,11 +6025,11 @@ class Ductape {
             try {
                 await this.redisClient.quit();
             }
-            catch (_b) {
+            catch (_d) {
                 try {
                     this.redisClient.disconnect(false);
                 }
-                catch ( /* best effort */_c) { /* best effort */ }
+                catch ( /* best effort */_e) { /* best effort */ }
             }
             this.redisClient = undefined;
         }
@@ -6183,8 +6273,32 @@ class Ductape {
             // Set the global instance for use by other services (e.g., database, storage)
             (0, secrets_1.setSecretsService)(this._secretsService);
         }
+        this.applyRuntimeCredentialBundle(this._secretsService);
         return this._secretsService;
     }
+    applyRuntimeCredentialBundle(service) {
+        var _a, _b, _c;
+        if (!this.runtimeCredentialBundle)
+            return;
+        const revision = (_a = this.runtimeManifest) === null || _a === void 0 ? void 0 : _a.secretRevision;
+        if (this.runtimeCredentialAppliedService === service && this.runtimeCredentialAppliedRevision === revision)
+            return;
+        try {
+            service.replaceRuntimeBundle(this.runtimeCredentialBundle.encrypted_secrets);
+            this.runtimeCredentialAppliedService = service;
+            this.runtimeCredentialAppliedRevision = revision;
+            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;
+            const missing = Math.max(0, referenced - cached);
+            this.runtimeCredentialState = {
+                status: missing ? 'incomplete' : 'ready', referenced, cached, missing, refreshedAt: Date.now(),
+            };
+        }
+        catch (error) {
+            this.runtimeCredentialState = Object.assign(Object.assign({}, this.runtimeCredentialState), { status: 'failed', error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
     async createNewCloudService() {
         const subCheck = false;
         if (!this.token || !this.public_key) {