@lumnsh/node 0.1.0

package/dist/index.mjs

@@ -0,0 +1,400 @@
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+
+// src/errors.ts
+var LumnError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LumnError";
+  }
+};
+var LumnApiError = class extends LumnError {
+  status;
+  code;
+  suggestion;
+  details;
+  constructor(status, body) {
+    super(body.message);
+    this.name = "LumnApiError";
+    this.status = status;
+    this.code = body.code;
+    this.suggestion = body.suggestion;
+    this.details = body.details;
+  }
+};
+var LumnAuthenticationError = class extends LumnApiError {
+  constructor(body) {
+    super(401, body);
+    this.name = "LumnAuthenticationError";
+  }
+};
+var LumnValidationError = class extends LumnApiError {
+  constructor(body) {
+    super(400, body);
+    this.name = "LumnValidationError";
+  }
+};
+var LumnNotFoundError = class extends LumnApiError {
+  constructor(body) {
+    super(404, body);
+    this.name = "LumnNotFoundError";
+  }
+};
+var LumnRateLimitError = class extends LumnApiError {
+  retryAfter;
+  constructor(body, retryAfter) {
+    super(429, body);
+    this.name = "LumnRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var LumnConnectionError = class extends LumnError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "LumnConnectionError";
+  }
+};
+var LumnTimeoutError = class extends LumnError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "LumnTimeoutError";
+  }
+};
+
+// src/resource.ts
+var ApiResource = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  async get(path, query) {
+    return this._client._request("GET", path, void 0, query);
+  }
+  async post(path, body) {
+    return this._client._request("POST", path, body);
+  }
+  async del(path, query) {
+    return this._client._request("DELETE", path, void 0, query);
+  }
+  async _list(path, params) {
+    const query = {};
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          query[key] = String(value);
+        }
+      }
+    }
+    const raw = await this._client._request("GET", path, void 0, query);
+    const result = {
+      data: raw.data,
+      hasMore: raw.has_more,
+      cursor: raw.cursor,
+      [Symbol.asyncIterator]: () => {
+        let currentData = raw.data;
+        let currentCursor = raw.cursor;
+        let currentHasMore = raw.has_more;
+        let index = 0;
+        return {
+          next: async () => {
+            if (index < currentData.length) {
+              return { value: currentData[index++], done: false };
+            }
+            if (!currentHasMore || !currentCursor) {
+              return { value: void 0, done: true };
+            }
+            const nextParams = { ...params, cursor: currentCursor };
+            const nextQuery = {};
+            for (const [key, value] of Object.entries(nextParams)) {
+              if (value !== void 0) {
+                nextQuery[key] = String(value);
+              }
+            }
+            const nextRaw = await this._client._request("GET", path, void 0, nextQuery);
+            currentData = nextRaw.data;
+            currentCursor = nextRaw.cursor;
+            currentHasMore = nextRaw.has_more;
+            index = 0;
+            if (currentData.length === 0) {
+              return { value: void 0, done: true };
+            }
+            return { value: currentData[index++], done: false };
+          }
+        };
+      }
+    };
+    return result;
+  }
+};
+
+// src/resources/customers.ts
+var Customers = class extends ApiResource {
+  async create(params) {
+    return this.post("/api/v1/customers", params);
+  }
+  async list(params) {
+    return this._list("/api/v1/customers", params);
+  }
+};
+
+// src/resources/products.ts
+var Products = class extends ApiResource {
+  async create(params) {
+    return this.post("/api/v1/products", params);
+  }
+  async list(params) {
+    return this._list("/api/v1/products", params);
+  }
+};
+
+// src/resources/features.ts
+var Features = class extends ApiResource {
+  async create(params) {
+    return this.post("/api/v1/features", params);
+  }
+  async list(params) {
+    return this._list("/api/v1/features", params);
+  }
+};
+
+// src/resources/entitlements.ts
+var Entitlements = class extends ApiResource {
+  async check(params) {
+    return this.get("/api/v1/entitlements", {
+      customer_id: params.customer_id,
+      feature_key: params.feature_key
+    });
+  }
+};
+
+// src/resources/payments.ts
+var Payments = class extends ApiResource {
+  async list(params) {
+    return this._list("/api/v1/payments", params);
+  }
+};
+
+// src/resources/subscriptions.ts
+var Subscriptions = class extends ApiResource {
+  async list(params) {
+    return this._list("/api/v1/subscriptions", params);
+  }
+};
+
+// src/resources/events.ts
+var Events = class extends ApiResource {
+  async list(params) {
+    return this._list("/api/v1/events", params);
+  }
+};
+
+// src/resources/meter.ts
+var Meter = class extends ApiResource {
+  async record(params) {
+    return this.post("/api/v1/meter", params);
+  }
+};
+
+// src/resources/sync.ts
+var Sync = class extends ApiResource {
+  async trigger(params) {
+    return this.post("/api/v1/sync", params);
+  }
+};
+
+// src/resources/connections.ts
+var Connections = class extends ApiResource {
+  async create(params) {
+    return this.post("/api/v1/connections", params);
+  }
+  async list() {
+    return this.get("/api/v1/connections");
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeys = class extends ApiResource {
+  async create(params) {
+    return this.post("/api/v1/api-keys", params);
+  }
+  async list() {
+    return this.get("/api/v1/api-keys");
+  }
+  async revoke(id) {
+    return this.del("/api/v1/api-keys", { id });
+  }
+};
+
+// src/resources/copy-config.ts
+var CopyConfig = class extends ApiResource {
+  async copy(params) {
+    return this.post("/api/v1/copy-config", params);
+  }
+};
+
+// src/resources/checkout.ts
+var Checkout = class extends ApiResource {
+  async create(params) {
+    return this.post("/api/v1/checkout", params);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://app.lumn.dev";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var Lumn = class {
+  _apiKey;
+  _baseUrl;
+  _timeout;
+  _maxRetries;
+  _fetch;
+  customers;
+  products;
+  features;
+  entitlements;
+  payments;
+  subscriptions;
+  events;
+  meter;
+  sync;
+  connections;
+  apiKeys;
+  copyConfig;
+  checkout;
+  constructor(config) {
+    if (config === void 0 || typeof config === "string") {
+      this._apiKey = config ?? "";
+      this._baseUrl = DEFAULT_BASE_URL;
+      this._timeout = DEFAULT_TIMEOUT;
+      this._maxRetries = DEFAULT_MAX_RETRIES;
+      this._fetch = globalThis.fetch;
+    } else {
+      this._apiKey = config.apiKey;
+      this._baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+      this._timeout = config.timeout ?? DEFAULT_TIMEOUT;
+      this._maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+      this._fetch = config.fetch ?? globalThis.fetch;
+    }
+    this.customers = new Customers(this);
+    this.products = new Products(this);
+    this.features = new Features(this);
+    this.entitlements = new Entitlements(this);
+    this.payments = new Payments(this);
+    this.subscriptions = new Subscriptions(this);
+    this.events = new Events(this);
+    this.meter = new Meter(this);
+    this.sync = new Sync(this);
+    this.connections = new Connections(this);
+    this.apiKeys = new ApiKeys(this);
+    this.copyConfig = new CopyConfig(this);
+    this.checkout = new Checkout(this);
+  }
+  /** @internal */
+  async _request(method, path, body, query) {
+    let lastError;
+    for (let attempt = 0; attempt <= this._maxRetries; attempt++) {
+      try {
+        const url = this._buildUrl(path, query);
+        const headers = {
+          Authorization: `Bearer ${this._apiKey}`,
+          "User-Agent": `@lumnsh/node/${SDK_VERSION}`
+        };
+        if (body !== void 0) {
+          headers["Content-Type"] = "application/json";
+        }
+        const response = await this._fetch(url, {
+          method,
+          headers,
+          body: body !== void 0 ? JSON.stringify(body) : void 0,
+          signal: AbortSignal.timeout(this._timeout)
+        });
+        if (!response.ok) {
+          const errorBody = await response.json().catch(() => ({
+            code: "unknown_error",
+            message: response.statusText
+          }));
+          const errorData = errorBody.error ?? errorBody;
+          if (response.status === 429) {
+            const retryAfter = response.headers.get("Retry-After");
+            const retryMs = retryAfter ? Number(retryAfter) * 1e3 : 1e3;
+            if (attempt < this._maxRetries) {
+              await this._sleep(retryMs);
+              continue;
+            }
+            throw new LumnRateLimitError(
+              errorData,
+              retryAfter ? Number(retryAfter) : null
+            );
+          }
+          if (response.status >= 500 && attempt < this._maxRetries) {
+            await this._sleep(1e3 * Math.pow(2, attempt));
+            continue;
+          }
+          this._throwTypedError(response.status, errorData);
+        }
+        const json = await response.json();
+        return json.data !== void 0 ? json.data : json;
+      } catch (error) {
+        if (error instanceof LumnApiError || error instanceof LumnConnectionError || error instanceof LumnTimeoutError) {
+          throw error;
+        }
+        if (error instanceof DOMException && error.name === "TimeoutError") {
+          throw new LumnTimeoutError(this._timeout);
+        }
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+          lastError = error;
+          if (attempt < this._maxRetries) {
+            await this._sleep(1e3 * Math.pow(2, attempt));
+            continue;
+          }
+          throw new LumnConnectionError(
+            `Failed to connect to ${this._baseUrl}`,
+            error
+          );
+        }
+        throw error;
+      }
+    }
+    throw lastError ?? new LumnConnectionError(`Failed after ${this._maxRetries + 1} attempts`);
+  }
+  _buildUrl(path, query) {
+    const url = new URL(path, this._baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  _throwTypedError(status, body) {
+    switch (status) {
+      case 401:
+        throw new LumnAuthenticationError(body);
+      case 400:
+        throw new LumnValidationError(body);
+      case 404:
+        throw new LumnNotFoundError(body);
+      default:
+        throw new LumnApiError(status, body);
+    }
+  }
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+export {
+  Lumn,
+  LumnApiError,
+  LumnAuthenticationError,
+  LumnConnectionError,
+  LumnError,
+  LumnNotFoundError,
+  LumnRateLimitError,
+  LumnTimeoutError,
+  LumnValidationError,
+  SDK_VERSION,
+  Lumn as default
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lumnsh/node",
+  "version": "0.1.0",
+  "description": "Official Lumn Node.js SDK — provider-agnostic payment orchestration",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.12.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.3",
+    "@lumn/typescript-config": "0.0.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "lumn",
+    "payments",
+    "payment-orchestration",
+    "billing",
+    "subscriptions"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rm -rf dist"
+  }
+}