@ductape/sdk 0.2.3 → 0.2.6

package/dist/index.d.ts

@@ -318,6 +318,9 @@ export default class Ductape implements IDuctape {
     private runtimeLastError?;
     private runtimePollTimer?;
     private runtimeRefreshInFlight?;
+    private runtimeWarmupEnabled;
+    private runtimeWarmupInFlight?;
+    private runtimeWarmupState?;
     private authInFlight?;
     private runtimeClosed;
     /** Register and inspect portable application functions used by Feature JSON. */
@@ -4342,6 +4345,7 @@ export default class Ductape implements IDuctape {
     private performUserAuth;
     private runtimeAuth;
     private applyRuntimeSnapshot;
+    private startRuntimeWarmup;
     private scheduleRuntimePoll;
     private pollRuntimeManifest;
     private refreshRuntimeSnapshot;
@@ -4364,6 +4368,26 @@ export default class Ductape implements IDuctape {
         lastRefreshAt: number;
         lastError: string;
         refreshing: boolean;
+        warmup: {
+            databases: {
+                tag: string;
+                status: "ready" | "failed";
+                durationMs: number;
+                error?: string;
+            }[];
+            warming: boolean;
+            startedAt: number;
+            completedAt?: number;
+            durationMs?: number;
+        } | {
+            warming: boolean;
+            databases: Array<{
+                tag: string;
+                status: "ready" | "failed";
+                durationMs: number;
+                error?: string;
+            }>;
+        };
     };
     /** Stop background synchronization and release SDK-owned background resources. */
     close(): Promise<void>;

package/dist/index.js

@@ -530,6 +530,7 @@ class Ductape {
         this.runtimePollIntervalMs = 30000;
         this.runtimePollJitter = 0.2;
         this.runtimeMaxBackoffMs = 300000;
+        this.runtimeWarmupEnabled = true;
         this.runtimeClosed = false;
         /** Register and inspect portable application functions used by Feature JSON. */
         this.functions = {
@@ -5453,6 +5454,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
@@ -5799,6 +5801,7 @@ class Ductape {
         var _a, _b, _c, _d, _e, _f, _g;
         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);
         const runtimeCredentials = new Map();
@@ -5846,6 +5849,49 @@ class Ductape {
         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;
@@ -5902,11 +5948,13 @@ class Ductape {
     /** Force a full product runtime refresh and atomically replace bootstrap cache entries. */
     async ready() {
         await this.initUserAuth(false);
+        await this.runtimeWarmupInFlight;
     }
     /** 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;
     }
     /** Observe the local product runtime snapshot without exposing cached configuration or secrets. */
     runtimeSnapshotStatus() {
@@ -5918,16 +5966,19 @@ class Ductape {
             lastRefreshAt: this.runtimeLastRefreshAt,
             lastError: this.runtimeLastError,
             refreshing: Boolean(this.runtimeRefreshInFlight),
+            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 +5986,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;
         }