@jewel998/config 0.2.6 → 0.2.7

package/dist/client/ConfigClient.js

@@ -32,7 +32,7 @@ export const buildConfigClient = (internals) => {
             batchFetchTriggered = true;
             void (async () => {
                 try {
-                    const result = await withRetry(() => fetcher.fetchAll(), retry);
+                    const { data: result } = await withRetry(() => fetcher.fetchAll(), retry);
                     cache.set("__all__", result, DEFAULT_CACHE_TTL);
                     for (const [key, value] of Object.entries(result)) {
                         cache.set(key, value, DEFAULT_CACHE_TTL);
@@ -58,7 +58,7 @@ export const buildConfigClient = (internals) => {
             return;
         void (async () => {
             try {
-                const result = await fetcher.fetchKeys([key]);
+                const { data: result } = await fetcher.fetchKeys([key]);
                 for (const [k, v] of Object.entries(result)) {
                     cache.set(k, v, DEFAULT_CACHE_TTL);
                     data[k] = v;

package/dist/client/RefreshManager.js

@@ -59,7 +59,11 @@ export class RefreshManager {
                 catch {
                     // If version check fails, proceed with full fetch as fallback
                 }
-                const result = await withRetry(() => fetcher.fetchAll(), retry);
+                const { data: result, version: responseVersion } = await withRetry(() => fetcher.fetchAll(), retry);
+                // Sync the version from the config response itself — avoids drifting
+                // from the value learned by the earlier checkVersion() probe.
+                if (responseVersion !== null)
+                    this.cachedVersion = responseVersion;
                 cache.set("__all__", result, DEFAULT_CACHE_TTL);
                 for (const [key, value] of Object.entries(result)) {
                     cache.set(key, value, DEFAULT_CACHE_TTL);

package/dist/fetch/TierFetcher.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigFetcher } from "../types.js";
+import type { ConfigFetcher, FetchResult } from "../types.js";
 export type FetchTier = "prefetch" | "page" | "idle";
 /**
  * TierFetcher — wraps a ConfigFetcher with three responsibilities:
@@ -24,12 +24,12 @@ export declare class TierFetcher {
      * Fetch a specific set of keys under a given tier.
      * Keys already tracked under any tier are skipped (deduplication).
      */
-    fetchTier(keys: string[], tier: FetchTier): Promise<Record<string, unknown>>;
+    fetchTier(keys: string[], tier: FetchTier): Promise<FetchResult>;
     /**
      * Fetch all remaining keys (idle tier).
      * Only keys not already tracked are added to the idle set.
      */
-    fetchAll(): Promise<Record<string, unknown>>;
+    fetchAll(): Promise<FetchResult>;
     /** Check the remote version (passthrough). */
     checkVersion(): ReturnType<ConfigFetcher["checkVersion"]>;
     /**
@@ -37,7 +37,7 @@ export declare class TierFetcher {
      * Used by doRefresh() — we're intentionally re-fetching already-fetched keys
      * with a new context, so the allFetched deduplication should be bypassed.
      */
-    refetchKeys(keys: string[]): Promise<Record<string, unknown>>;
+    refetchKeys(keys: string[]): Promise<FetchResult>;
     /**
      * Record keys as fetched under a tier WITHOUT performing a network fetch.
      * Used when values are hydrated from persistent storage (the boot gate),

package/dist/fetch/TierFetcher.js

@@ -36,9 +36,9 @@ export class TierFetcher {
     async fetchTier(keys, tier) {
         const toFetch = keys.filter((k) => !this.allFetched.has(k));
         if (toFetch.length === 0)
-            return {};
+            return { data: {}, version: null };
         const result = await this.fetcher.fetchKeys(toFetch);
-        this.recordKeys(Object.keys(result), tier);
+        this.recordKeys(Object.keys(result.data), tier);
         return result;
     }
     /**
@@ -47,7 +47,7 @@ export class TierFetcher {
      */
     async fetchAll() {
         const result = await this.fetcher.fetchAll();
-        for (const key of Object.keys(result)) {
+        for (const key of Object.keys(result.data)) {
             if (!this.allFetched.has(key)) {
                 this.fetchedKeys.get("idle").add(key);
                 this.allFetched.add(key);

package/dist/fetch/batchFetcher.js

@@ -1,12 +1,12 @@
 export const createBatchFetcher = (transport) => ({
     async fetchAll() {
         const response = await transport.request("v1/config");
-        return response.data;
+        return { data: response.data, version: response.version ?? null };
     },
     async fetchKeys(_keys) {
         // Batch mode always fetches everything
         const response = await transport.request("v1/config");
-        return response.data;
+        return { data: response.data, version: response.version ?? null };
     },
     async checkVersion() {
         const response = await transport.request("v1/version");

package/dist/fetch/projectedFetcher.js

@@ -4,7 +4,7 @@ export const createProjectedFetcher = (transport) => {
     return {
         async fetchAll() {
             const response = await transport.request("v1/config");
-            return response.data;
+            return { data: response.data, version: response.version ?? null };
         },
         async fetchKeys(keys) {
             for (const key of keys) {
@@ -20,7 +20,7 @@ export const createProjectedFetcher = (transport) => {
                             const response = await transport.request("v1/config", {
                                 keys: batchedKeys,
                             });
-                            resolve(response.data);
+                            resolve({ data: response.data, version: response.version ?? null });
                         }
                         catch (err) {
                             reject(err);
@@ -32,11 +32,11 @@ export const createProjectedFetcher = (transport) => {
             // Return only the keys this caller requested
             const filtered = {};
             for (const key of keys) {
-                if (key in result) {
-                    filtered[key] = result[key];
+                if (key in result.data) {
+                    filtered[key] = result.data[key];
                 }
             }
-            return filtered;
+            return { data: filtered, version: result.version };
         },
         async checkVersion() {
             const response = await transport.request("v1/version");

package/dist/initConfig.js

@@ -180,12 +180,12 @@ export function initConfig(options) {
                         cachedVersion = remote;
                 }
                 const result = await withRetry(() => tierFetcher.fetchTier(initPrefetch, "prefetch"), retry);
-                const fetched = applyResult(result);
-                // Record the version these values correspond to.
-                const v = await fetchRemoteVersion();
-                if (v !== null)
-                    persistVersion(v);
-                tierFetcher.notifyWaiters(result);
+                const fetched = applyResult(result.data);
+                // Persist the version delivered alongside these values — no extra
+                // /version round trip needed; the /config response carries it.
+                if (result.version !== null)
+                    persistVersion(result.version);
+                tierFetcher.notifyWaiters(result.data);
                 emitUpdated(fetched, "prefetch");
             }
             catch (err) {
@@ -214,11 +214,10 @@ export function initConfig(options) {
                         cachedVersion = remote;
                 }
                 const result = await tierFetcher.fetchAll();
-                const fetched = applyResult(result);
-                const v = await fetchRemoteVersion();
-                if (v !== null)
-                    persistVersion(v);
-                tierFetcher.notifyWaiters(result);
+                const fetched = applyResult(result.data);
+                if (result.version !== null)
+                    persistVersion(result.version);
+                tierFetcher.notifyWaiters(result.data);
                 emitUpdated(fetched, "idle");
             }
             catch {
@@ -261,18 +260,22 @@ export function initConfig(options) {
         if (pf.length > 0) {
             refetches.push(withRetry(() => tierFetcher.refetchKeys(pf), retry)
                 .then((r) => {
-                applyResult(r);
-                tierFetcher.notifyWaiters(r);
-                allFetched.push(...Object.keys(r));
+                applyResult(r.data);
+                if (r.version !== null)
+                    persistVersion(r.version);
+                tierFetcher.notifyWaiters(r.data);
+                allFetched.push(...Object.keys(r.data));
             })
                 .catch(() => { }));
         }
         if (page.length > 0) {
             refetches.push(withRetry(() => tierFetcher.refetchKeys(page), retry)
                 .then((r) => {
-                applyResult(r);
-                tierFetcher.notifyWaiters(r);
-                allFetched.push(...Object.keys(r));
+                applyResult(r.data);
+                if (r.version !== null)
+                    persistVersion(r.version);
+                tierFetcher.notifyWaiters(r.data);
+                allFetched.push(...Object.keys(r.data));
             })
                 .catch(() => { }));
         }
@@ -280,9 +283,11 @@ export function initConfig(options) {
             refetches.push(tierFetcher
                 .fetchAll()
                 .then((r) => {
-                applyResult(r);
-                tierFetcher.notifyWaiters(r);
-                allFetched.push(...Object.keys(r));
+                applyResult(r.data);
+                if (r.version !== null)
+                    persistVersion(r.version);
+                tierFetcher.notifyWaiters(r.data);
+                allFetched.push(...Object.keys(r.data));
             })
                 .catch(() => { }));
         }
@@ -300,8 +305,10 @@ export function initConfig(options) {
             void (async () => {
                 try {
                     const result = await withRetry(() => tierFetcher.fetchTier(keys, "page"), retry);
-                    const fetched = applyResult(result);
-                    tierFetcher.notifyWaiters(result);
+                    const fetched = applyResult(result.data);
+                    if (result.version !== null)
+                        persistVersion(result.version);
+                    tierFetcher.notifyWaiters(result.data);
                     emitUpdated(fetched, "page");
                 }
                 catch (err) {

package/dist/loading/optimistic.js

@@ -3,7 +3,7 @@ import { DEFAULT_CACHE_TTL } from "../types.js";
 const scheduleBackgroundFetch = (ctx) => {
     const doFetch = async () => {
         try {
-            const data = await withRetry(() => ctx.fetcher.fetchAll(), ctx.retry);
+            const { data } = await withRetry(() => ctx.fetcher.fetchAll(), ctx.retry);
             ctx.cache.set("__all__", data, DEFAULT_CACHE_TTL);
             for (const [key, value] of Object.entries(data)) {
                 ctx.cache.set(key, value, DEFAULT_CACHE_TTL);

package/dist/loading/pessimistic.js

@@ -7,7 +7,7 @@ export const executePessimistic = async (ctx) => {
         setTimeout(() => reject(new TimeoutError(ctx.timeout)), ctx.timeout);
     });
     try {
-        const data = await Promise.race([fetchPromise, timeoutPromise]);
+        const { data } = await Promise.race([fetchPromise, timeoutPromise]);
         ctx.cache.set("__all__", data, DEFAULT_CACHE_TTL);
         for (const [key, value] of Object.entries(data)) {
             ctx.cache.set(key, value, DEFAULT_CACHE_TTL);

package/dist/types.d.ts

@@ -137,11 +137,22 @@ export interface LoadingResult {
 export interface LoadingStrategyHandler {
     execute(context: LoadingContext): LoadingResult | Promise<LoadingResult>;
 }
+/**
+ * Result of a config fetch — the resolved values plus the config version
+ * they correspond to. The version comes from the same `/config` response
+ * that delivered the data, so the SDK can persist it without a second
+ * `/version` round trip.
+ */
+export interface FetchResult {
+    data: Record<string, unknown>;
+    /** Config version from the response, or null if the response omitted it. */
+    version: string | null;
+}
 export interface ConfigFetcher {
     /** Fetch all configs for the bound project+environment */
-    fetchAll(): Promise<Record<string, unknown>>;
+    fetchAll(): Promise<FetchResult>;
     /** Fetch specific keys only */
-    fetchKeys(keys: string[]): Promise<Record<string, unknown>>;
+    fetchKeys(keys: string[]): Promise<FetchResult>;
     /** Check current config version (lightweight — single Firestore read) */
     checkVersion(): Promise<{
         version: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jewel998/config",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "private": false,
   "description": "Free, self-hosted feature flags and remote configuration SDK",
   "keywords": [