@smplkit/sdk 1.2.6 → 1.3.0

package/dist/index.cjs

@@ -55,6 +55,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/client.ts
+var import_openapi_fetch3 = __toESM(require("openapi-fetch"), 1);
+
 // src/config/client.ts
 var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
 
@@ -721,135 +724,6 @@ var ConfigClient = class {
 // src/flags/client.ts
 var import_openapi_fetch2 = __toESM(require("openapi-fetch"), 1);
 
-// src/auth.ts
-function buildAuthHeader(apiKey) {
-  return `Bearer ${apiKey}`;
-}
-
-// src/transport.ts
-var SDK_VERSION = "0.0.0";
-var DEFAULT_TIMEOUT_MS = 3e4;
-var Transport = class {
-  apiKey;
-  timeout;
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
-  }
-  /**
-   * Send a GET request.
-   *
-   * @param url - Fully-qualified URL (e.g. `https://config.smplkit.com/api/v1/configs`).
-   * @param params - Optional query parameters.
-   * @returns Parsed JSON response body.
-   */
-  async get(url, params) {
-    return this.request("GET", url, void 0, params);
-  }
-  /**
-   * Send a POST request with a JSON body.
-   *
-   * @param url - Fully-qualified URL.
-   * @param body - JSON-serializable request body.
-   * @returns Parsed JSON response body.
-   */
-  async post(url, body) {
-    return this.request("POST", url, body);
-  }
-  /**
-   * Send a PUT request with a JSON body.
-   *
-   * @param url - Fully-qualified URL.
-   * @param body - JSON-serializable request body.
-   * @returns Parsed JSON response body.
-   */
-  async put(url, body) {
-    return this.request("PUT", url, body);
-  }
-  /**
-   * Send a DELETE request.
-   *
-   * @param url - Fully-qualified URL.
-   * @returns Parsed JSON response body (empty object for 204 responses).
-   */
-  async delete(url) {
-    return this.request("DELETE", url);
-  }
-  /**
-   * Core request method. Handles headers, timeouts, and error mapping.
-   */
-  async request(method, url, body, params) {
-    if (params) {
-      const searchParams = new URLSearchParams(params);
-      url += `?${searchParams.toString()}`;
-    }
-    const headers = {
-      Authorization: buildAuthHeader(this.apiKey),
-      "User-Agent": `smplkit-typescript-sdk/${SDK_VERSION}`,
-      Accept: "application/vnd.api+json"
-    };
-    if (body !== void 0) {
-      headers["Content-Type"] = "application/vnd.api+json";
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    let response;
-    try {
-      response = await fetch(url, {
-        method,
-        headers,
-        body: body !== void 0 ? JSON.stringify(body) : void 0,
-        signal: controller.signal
-      });
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new SmplTimeoutError(`Request timed out after ${this.timeout}ms`);
-      }
-      if (error instanceof TypeError) {
-        throw new SmplConnectionError(`Network error: ${error.message}`);
-      }
-      throw new SmplConnectionError(
-        `Request failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    } finally {
-      clearTimeout(timeoutId);
-    }
-    if (response.status === 204) {
-      return {};
-    }
-    const responseText = await response.text();
-    if (!response.ok) {
-      this.throwForStatus(response.status, responseText);
-    }
-    try {
-      return JSON.parse(responseText);
-    } catch {
-      throw new SmplError(`Invalid JSON response: ${responseText}`, response.status, responseText);
-    }
-  }
-  /**
-   * Map HTTP error status codes to typed SDK exceptions.
-   *
-   * @throws {SmplNotFoundError} On 404.
-   * @throws {SmplConflictError} On 409.
-   * @throws {SmplValidationError} On 422.
-   * @throws {SmplError} On any other non-2xx status.
-   */
-  throwForStatus(status, body) {
-    switch (status) {
-      case 404:
-        throw new SmplNotFoundError(body, 404, body);
-      case 409:
-        throw new SmplConflictError(body, 409, body);
-      case 422:
-        throw new SmplValidationError(body, 422, body);
-      default:
-        throw new SmplError(`HTTP ${status}: ${body}`, status, body);
-    }
-  }
-};
-
 // src/flags/models.ts
 var Flag = class {
   /** UUID of the flag. */
@@ -1201,8 +1075,8 @@ var ContextRegistrationBuffer = class {
         }
         this._seen.set(cacheKey, ctx.attributes);
         this._pending.push({
-          id: `${ctx.type}:${ctx.key}`,
-          name: ctx.name ?? ctx.key,
+          type: ctx.type,
+          key: ctx.key,
           attributes: { ...ctx.attributes }
         });
       }
@@ -1225,7 +1099,7 @@ var FlagsClient = class {
   /** @internal */
   _http;
   /** @internal */
-  _transport;
+  _appHttp;
   // Runtime state
   _environment = null;
   _flagStore = {};
@@ -1245,28 +1119,36 @@ var FlagsClient = class {
     this._apiKey = apiKey;
     this._ensureWs = ensureWs;
     const ms = timeout ?? 3e4;
+    const fetchWithTimeout = async (request) => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), ms);
+      try {
+        return await fetch(new Request(request, { signal: controller.signal }));
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+          throw new SmplTimeoutError(`Request timed out after ${ms}ms`);
+        }
+        throw err;
+      } finally {
+        clearTimeout(timer);
+      }
+    };
     this._http = (0, import_openapi_fetch2.default)({
       baseUrl: FLAGS_BASE_URL,
       headers: {
         Authorization: `Bearer ${apiKey}`,
         Accept: "application/json"
       },
-      fetch: async (request) => {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), ms);
-        try {
-          return await fetch(new Request(request, { signal: controller.signal }));
-        } catch (err) {
-          if (err instanceof DOMException && err.name === "AbortError") {
-            throw new SmplTimeoutError(`Request timed out after ${ms}ms`);
-          }
-          throw err;
-        } finally {
-          clearTimeout(timer);
-        }
-      }
+      fetch: fetchWithTimeout
+    });
+    this._appHttp = (0, import_openapi_fetch2.default)({
+      baseUrl: APP_BASE_URL,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      },
+      fetch: fetchWithTimeout
     });
-    this._transport = new Transport({ apiKey, timeout: ms });
   }
   // ------------------------------------------------------------------
   // Management methods
@@ -1381,40 +1263,87 @@ var FlagsClient = class {
     return this._resourceToModel(data.data);
   }
   // ------------------------------------------------------------------
-  // Context type management (direct HTTP — not in generated spec)
+  // Context type management (via generated app client)
   // ------------------------------------------------------------------
   /** Create a context type. */
   async createContextType(key, options) {
-    const resp = await this._transport.post(`${APP_BASE_URL}/api/v1/context_types`, {
-      data: { type: "context_type", attributes: { key, name: options.name } }
-    });
-    const data = resp.data ?? {};
-    return this._parseContextType(data);
+    let data;
+    try {
+      const result = await this._appHttp.POST("/api/v1/context_types", {
+        body: {
+          data: { type: "context_type", attributes: { key, name: options.name } }
+        }
+      });
+      if (result.error !== void 0)
+        await checkError2(result.response, "Failed to create context type");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError2(err);
+    }
+    if (!data || !data.data) throw new SmplValidationError("Failed to create context type");
+    return this._parseContextType(data.data);
   }
   /** Update a context type (merge attributes). */
   async updateContextType(ctId, options) {
-    const resp = await this._transport.put(`${APP_BASE_URL}/api/v1/context_types/${ctId}`, {
-      data: { type: "context_type", attributes: { attributes: options.attributes } }
-    });
-    const data = resp.data ?? {};
-    return this._parseContextType(data);
+    let data;
+    try {
+      const result = await this._appHttp.PUT("/api/v1/context_types/{id}", {
+        params: { path: { id: ctId } },
+        body: {
+          data: {
+            type: "context_type",
+            attributes: { key: options.key, name: options.name, attributes: options.attributes }
+          }
+        }
+      });
+      if (result.error !== void 0)
+        await checkError2(result.response, `Failed to update context type ${ctId}`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError2(err);
+    }
+    if (!data || !data.data) throw new SmplValidationError(`Failed to update context type ${ctId}`);
+    return this._parseContextType(data.data);
   }
   /** List all context types. */
   async listContextTypes() {
-    const resp = await this._transport.get(`${APP_BASE_URL}/api/v1/context_types`);
-    const items = resp.data ?? [];
-    return items.map((item) => this._parseContextType(item));
+    let data;
+    try {
+      const result = await this._appHttp.GET("/api/v1/context_types");
+      if (result.error !== void 0)
+        await checkError2(result.response, "Failed to list context types");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError2(err);
+    }
+    if (!data || !data.data) throw new SmplValidationError("Failed to list context types");
+    return data.data.map((item) => this._parseContextType(item));
   }
   /** Delete a context type. */
   async deleteContextType(ctId) {
-    await this._transport.delete(`${APP_BASE_URL}/api/v1/context_types/${ctId}`);
+    try {
+      const result = await this._appHttp.DELETE("/api/v1/context_types/{id}", {
+        params: { path: { id: ctId } }
+      });
+      if (result.error !== void 0 && result.response.status !== 204)
+        await checkError2(result.response, `Failed to delete context type ${ctId}`);
+    } catch (err) {
+      wrapFetchError2(err);
+    }
   }
   /** List context instances filtered by context type key. */
   async listContexts(options) {
-    const resp = await this._transport.get(`${APP_BASE_URL}/api/v1/contexts`, {
-      "filter[context_type]": options.contextTypeKey
-    });
-    return resp.data ?? [];
+    let data;
+    try {
+      const result = await this._appHttp.GET("/api/v1/contexts", {
+        params: { query: { "filter[context_type_id]": options.contextTypeKey } }
+      });
+      if (result.error !== void 0) await checkError2(result.response, "Failed to list contexts");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError2(err);
+    }
+    return data?.data ?? [];
   }
   // ------------------------------------------------------------------
   // Runtime: typed flag handles
@@ -1704,8 +1633,13 @@ var FlagsClient = class {
     const batch = this._contextBuffer.drain();
     if (batch.length === 0) return;
     try {
-      await this._transport.post(`${APP_BASE_URL}/api/v1/contexts/bulk`, {
-        contexts: batch
+      await this._appHttp.POST("/api/v1/contexts/bulk", {
+        body: {
+          contexts: batch.map((ctx) => ({
+            id: `${ctx.type}:${ctx.key}`,
+            attributes: ctx.attributes
+          }))
+        }
       });
     } catch {
     }
@@ -1951,6 +1885,7 @@ var SmplClient = class {
   _service;
   _connected = false;
   _timeout;
+  _appHttp;
   constructor(options = {}) {
     const apiKey = resolveApiKey(options.apiKey);
     this._apiKey = apiKey;
@@ -1961,6 +1896,28 @@ var SmplClient = class {
     this._environment = environment;
     this._service = options.service || process.env.SMPLKIT_SERVICE || null;
     this._timeout = options.timeout ?? 3e4;
+    const ms = this._timeout;
+    this._appHttp = (0, import_openapi_fetch3.default)({
+      baseUrl: APP_BASE_URL2,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      },
+      fetch: async (request) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), ms);
+        try {
+          return await fetch(new Request(request, { signal: controller.signal }));
+        } catch (err) {
+          if (err instanceof DOMException && err.name === "AbortError") {
+            throw new SmplTimeoutError(`Request timed out after ${ms}ms`);
+          }
+          throw err;
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+    });
     this.config = new ConfigClient(apiKey, this._timeout);
     this.flags = new FlagsClient(apiKey, () => this._ensureWs(), this._timeout);
     this.config._getSharedWs = () => this._ensureWs();
@@ -1987,21 +1944,15 @@ var SmplClient = class {
   /** @internal */
   async _registerServiceContext() {
     try {
-      await fetch(`${APP_BASE_URL2}/api/v1/contexts/bulk`, {
-        method: "PUT",
-        headers: {
-          Authorization: `Bearer ${this._apiKey}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
+      await this._appHttp.POST("/api/v1/contexts/bulk", {
+        body: {
           contexts: [
             {
-              type: "service",
-              key: this._service,
+              id: `service:${this._service}`,
               attributes: { name: this._service }
             }
           ]
-        })
+        }
       });
     } catch {
     }