@quonfig/node 0.0.1 → 0.0.3

package/README.md

@@ -55,7 +55,8 @@ new Quonfig({
   initTimeout: 10000,            // Init timeout in ms (default: 10000)
   onNoDefault: "error",          // "error" | "warn" | "ignore" (default: "error")
   globalContext: { ... },        // Context applied to all evaluations
-  datafile: "./config.json",     // Load from file instead of API
+  datadir: "./workspace-data",   // Load local workspace directories instead of API
+  datafile: "./config.json",     // Legacy local envelope path
 });
 ```
 

package/dist/index.cjs

@@ -93,7 +93,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/quonfig.ts
 var import_crypto3 = require("crypto");
-var import_fs = require("fs");
+var import_fs2 = require("fs");
 
 // src/store.ts
 var ConfigStore = class {
@@ -918,12 +918,14 @@ function valueTypeForCoerced(valueType) {
 var SDK_VERSION = "0.1.0";
 var DEFAULT_TELEMETRY_URL = "https://telemetry.quonfig.com";
 var Transport = class {
-  baseUrl;
+  baseUrls;
+  activeBaseUrl;
   telemetryBaseUrl;
   sdkKey;
   etag = "";
-  constructor(baseUrl, sdkKey, telemetryBaseUrl) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
+  constructor(baseUrls, sdkKey, telemetryBaseUrl) {
+    this.baseUrls = baseUrls.map((u) => u.replace(/\/$/, ""));
+    this.activeBaseUrl = this.baseUrls[0];
     const envUrl = process.env.QUONFIG_TELEMETRY_URL;
     const url = envUrl || telemetryBaseUrl || DEFAULT_TELEMETRY_URL;
     this.telemetryBaseUrl = url.replace(/\/$/, "");
@@ -950,30 +952,41 @@ var Transport = class {
   /**
    * Fetch configs from GET /api/v2/configs with ETag caching.
    *
+   * Tries each base URL in order. Returns the first successful result.
    * Returns `{ notChanged: true }` if the server responds with 304.
    */
   async fetchConfigs() {
-    const headers = this.getHeaders();
-    if (this.etag) {
-      headers["If-None-Match"] = this.etag;
-    }
-    const response = await fetch(`${this.baseUrl}/api/v2/configs`, {
-      method: "GET",
-      headers
-    });
-    if (response.status === 304) {
-      return { notChanged: true };
-    }
-    if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      throw new Error(`Unexpected status ${response.status}: ${body}`);
-    }
-    const etag = response.headers.get("ETag");
-    if (etag) {
-      this.etag = etag;
+    let lastError;
+    for (const baseUrl of this.baseUrls) {
+      try {
+        const headers = this.getHeaders();
+        if (this.etag) {
+          headers["If-None-Match"] = this.etag;
+        }
+        const response = await fetch(`${baseUrl}/api/v2/configs`, {
+          method: "GET",
+          headers
+        });
+        if (response.status === 304) {
+          this.activeBaseUrl = baseUrl;
+          return { notChanged: true };
+        }
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          throw new Error(`Unexpected status ${response.status} from ${baseUrl}: ${body}`);
+        }
+        const etag = response.headers.get("ETag");
+        if (etag) {
+          this.etag = etag;
+        }
+        this.activeBaseUrl = baseUrl;
+        const envelope = await response.json();
+        return { envelope, notChanged: false };
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+      }
     }
-    const envelope = await response.json();
-    return { envelope, notChanged: false };
+    throw lastError ?? new Error("All API URLs failed");
   }
   /**
    * Post telemetry data to the telemetry endpoint.
@@ -994,9 +1007,10 @@ var Transport = class {
   }
   /**
    * Get the SSE URL for config streaming.
+   * Uses whichever base URL last succeeded for fetchConfigs.
    */
   getSSEUrl() {
-    return `${this.baseUrl}/api/v2/sse/config`;
+    return `${this.activeBaseUrl}/api/v2/sse/config`;
   }
   /**
    * Get auth headers for SSE connection.
@@ -1101,7 +1115,10 @@ function shouldLog(args) {
   while (loggerNameWithPrefix.includes(".")) {
     const resolvedLevel = getConfig(loggerNameWithPrefix);
     if (resolvedLevel !== void 0) {
-      return Number(resolvedLevel) <= desiredLevel;
+      const resolvedLevelNum = parseLevel(resolvedLevel);
+      if (resolvedLevelNum !== void 0) {
+        return resolvedLevelNum <= desiredLevel;
+      }
     }
     loggerNameWithPrefix = loggerNameWithPrefix.slice(
       0,
@@ -1111,6 +1128,87 @@ function shouldLog(args) {
   return defaultLevel <= desiredLevel;
 }
 
+// src/datadir.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var CONFIG_SUBDIRS = ["configs", "feature-flags", "segments", "schemas", "log-levels"];
+function loadEnvelopeFromDatadir(datadir) {
+  const environmentId = loadEnvironmentId((0, import_path.join)(datadir, "environments.json"));
+  const configs = [];
+  for (const subdir of CONFIG_SUBDIRS) {
+    const dir = (0, import_path.join)(datadir, subdir);
+    if (!(0, import_fs.existsSync)(dir)) {
+      continue;
+    }
+    const filenames = (0, import_fs.readdirSync)(dir).filter((filename) => filename.endsWith(".json")).sort((a, b) => a.localeCompare(b));
+    for (const filename of filenames) {
+      const raw = JSON.parse((0, import_fs.readFileSync)((0, import_path.join)(dir, filename), "utf-8"));
+      configs.push(toConfigResponse(raw, environmentId));
+    }
+  }
+  return {
+    configs,
+    meta: {
+      version: `datadir:${datadir}`,
+      environment: environmentId
+    }
+  };
+}
+function loadEnvironmentId(environmentsPath) {
+  if (!(0, import_fs.existsSync)(environmentsPath)) {
+    throw new Error(`[quonfig] Datadir is missing environments.json: ${environmentsPath}`);
+  }
+  const environments = JSON.parse((0, import_fs.readFileSync)(environmentsPath, "utf-8"));
+  const candidates = normalizeEnvironmentCandidates(
+    isWrappedEnvironmentList(environments) ? environments.environments : environments
+  );
+  if (candidates.length === 0) {
+    return "";
+  }
+  return candidates[0];
+}
+function isWrappedEnvironmentList(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && "environments" in value
+  );
+}
+function normalizeEnvironmentCandidates(environments) {
+  if (!environments) {
+    return [];
+  }
+  if (Array.isArray(environments)) {
+    return environments.map((entry) => {
+      if (typeof entry === "string") {
+        return entry;
+      }
+      if (entry && typeof entry === "object") {
+        return entry.id ?? entry.name;
+      }
+      return void 0;
+    }).filter((entry) => typeof entry === "string" && entry.length > 0);
+  }
+  if (environments && typeof environments === "object") {
+    const values = Object.values(environments).map((value) => typeof value === "string" && value.length > 0 ? value : void 0).filter((value) => typeof value === "string");
+    if (values.length > 0) {
+      return values;
+    }
+    return Object.keys(environments).filter((key) => key.length > 0);
+  }
+  return [];
+}
+function toConfigResponse(raw, environmentId) {
+  const environment = raw.environments?.find((candidate) => candidate.id === environmentId);
+  return {
+    id: raw.id ?? "",
+    key: raw.key,
+    type: raw.type,
+    valueType: raw.valueType,
+    sendToClientSdk: raw.sendToClientSdk ?? false,
+    default: raw.default ?? { rules: [] },
+    environment
+  };
+}
+
 // src/telemetry/evaluationSummaries.ts
 var EvaluationSummaryCollector = class {
   enabled;
@@ -1380,7 +1478,10 @@ var TelemetryReporter = class {
 };
 
 // src/quonfig.ts
-var DEFAULT_API_URL = "https://api.quonfig.com";
+var DEFAULT_API_URLS = [
+  "https://primary.quonfig.com",
+  "https://secondary.quonfig.com"
+];
 var DEFAULT_POLL_INTERVAL = 6e4;
 var DEFAULT_INIT_TIMEOUT = 1e4;
 var DEFAULT_LOG_LEVEL = 5;
@@ -1421,6 +1522,9 @@ var BoundQuonfig = class _BoundQuonfig {
       contexts: mergeContexts(this.boundContexts, args.contexts)
     });
   }
+  async flush() {
+    return this.client.flush();
+  }
   keys() {
     return this.client.keys();
   }
@@ -1430,7 +1534,7 @@ var BoundQuonfig = class _BoundQuonfig {
 };
 var Quonfig = class {
   sdkKey;
-  apiUrl;
+  apiUrls;
   telemetryUrl;
   enableSSE;
   enablePolling;
@@ -1439,6 +1543,7 @@ var Quonfig = class {
   onNoDefault;
   globalContext;
   initTimeout;
+  datadir;
   datafile;
   store;
   evaluator;
@@ -1456,7 +1561,10 @@ var Quonfig = class {
   exampleContexts;
   constructor(options) {
     this.sdkKey = options.sdkKey;
-    this.apiUrl = (options.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
+    this.apiUrls = options.apiUrls ?? (options.apiUrl ? [options.apiUrl] : DEFAULT_API_URLS);
+    if (this.apiUrls.length === 0) {
+      throw new Error("[quonfig] apiUrls must not be empty");
+    }
     this.telemetryUrl = options.telemetryUrl;
     this.enableSSE = options.enableSSE ?? true;
     this.enablePolling = options.enablePolling ?? false;
@@ -1465,12 +1573,13 @@ var Quonfig = class {
     this.onNoDefault = options.onNoDefault ?? "error";
     this.globalContext = options.globalContext;
     this.initTimeout = options.initTimeout ?? DEFAULT_INIT_TIMEOUT;
+    this.datadir = options.datadir;
     this.datafile = options.datafile;
     this.instanceHash = (0, import_crypto3.randomUUID)();
     this.store = new ConfigStore();
     this.evaluator = new Evaluator(this.store);
     this.resolver = new Resolver(this.store, this.evaluator);
-    this.transport = new Transport(this.apiUrl, this.sdkKey, this.telemetryUrl);
+    this.transport = new Transport(this.apiUrls, this.sdkKey, this.telemetryUrl);
     const contextUploadMode = options.contextUploadMode ?? "periodic_example";
     this.evaluationSummaries = new EvaluationSummaryCollector(
       options.collectEvaluationSummaries ?? true
@@ -1479,14 +1588,14 @@ var Quonfig = class {
     this.exampleContexts = new ExampleContextCollector(contextUploadMode);
   }
   /**
-   * Initialize the SDK. Downloads configs from the API (or loads from datafile)
+   * Initialize the SDK. Downloads configs from the API (or loads from datadir/datafile)
    * and starts background update mechanisms (SSE/polling).
    *
    * Must be called before using any get* methods.
    */
   async init() {
-    if (this.datafile) {
-      this.loadDatafile();
+    if (this.datadir || this.datafile) {
+      this.loadLocalData();
       this.initialized = true;
       return;
     }
@@ -1654,6 +1763,22 @@ var Quonfig = class {
   inContext(contexts) {
     return new BoundQuonfig(this, mergeContexts(this.globalContext, contexts));
   }
+  /**
+   * Flush pending telemetry data immediately. Useful in serverless environments
+   * (Vercel, Lambda) where the process may be frozen before the background
+   * timer fires.
+   *
+   * ```typescript
+   * const value = quonfig.get("my-flag", contexts);
+   * await quonfig.flush();
+   * return NextResponse.json({ value });
+   * ```
+   */
+  async flush() {
+    if (this.telemetryReporter) {
+      await this.telemetryReporter.sync();
+    }
+  }
   /**
    * Close the SDK. Stops SSE, polling, and telemetry.
    */
@@ -1691,19 +1816,24 @@ var Quonfig = class {
         return void 0;
     }
   }
-  loadDatafile() {
-    let data;
-    if (typeof this.datafile === "string") {
-      const raw = (0, import_fs.readFileSync)(this.datafile, "utf-8");
-      data = JSON.parse(raw);
-    } else if (typeof this.datafile === "object") {
-      data = this.datafile;
-    } else {
-      throw new Error("Invalid datafile option");
-    }
+  loadLocalData() {
+    const data = this.loadLocalEnvelope();
     this.store.update(data);
     this.environmentId = data.meta.environment;
   }
+  loadLocalEnvelope() {
+    if (this.datadir) {
+      return loadEnvelopeFromDatadir(this.datadir);
+    }
+    if (typeof this.datafile === "string") {
+      const raw = (0, import_fs2.readFileSync)(this.datafile, "utf-8");
+      return JSON.parse(raw);
+    }
+    if (typeof this.datafile === "object") {
+      return this.datafile;
+    }
+    throw new Error("Invalid local configuration: expected datadir or datafile");
+  }
   async fetchAndInstall() {
     const result = await this.transport.fetchConfigs();
     if (result.notChanged) {
@@ -1797,11 +1927,28 @@ var Client = class {
   }
   async post(path, payload) {
     const url = `${this.apiUrl}${path}`;
+    const isORPC = path.startsWith("/api/v1/");
     this.log("ApiClient", `POST ${url}`);
-    return fetch(url, {
+    const body = isORPC ? JSON.stringify({ json: payload }) : JSON.stringify(payload);
+    const raw = await fetch(url, {
       method: "POST",
       headers: this.headers(),
-      body: JSON.stringify(payload)
+      body
+    });
+    if (!isORPC) return raw;
+    const text = await raw.text();
+    let unwrapped = text;
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed && typeof parsed === "object" && "json" in parsed) {
+        unwrapped = JSON.stringify(parsed.json);
+      }
+    } catch {
+    }
+    return new Response(unwrapped, {
+      status: raw.status,
+      statusText: raw.statusText,
+      headers: raw.headers
     });
   }
   async put(path, payload) {