revenuecat-api 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import createClient, { type ClientOptions } from "openapi-fetch";
+import type { paths } from "./__generated/revenuecat-api-v2";
+export * from "./__generated/revenuecat-api-v2";
+export type CreateRevenueCatClientOptions = ClientOptions & {
+    automaticRateLimit?: boolean;
+};
+export declare function createRevenueCatClient(accessToken: string, options?: CreateRevenueCatClientOptions): createClient.PathBasedClient<paths, `${string}/${string}`>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,EAAE,EACnB,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAG7D,cAAc,iCAAiC,CAAC;AAEhD,MAAM,MAAM,6BAA6B,GAAG,aAAa,GAAG;IAC1D,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAOF,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,6BAA6B,8DA2BxC"}

package/dist/index.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRevenueCatClient = createRevenueCatClient;
+const openapi_fetch_1 = __importStar(require("openapi-fetch"));
+const rateLimitMiddleware_1 = require("./rateLimitMiddleware");
+__exportStar(require("./__generated/revenuecat-api-v2"), exports);
+const defaultOptions = {
+    baseUrl: "https://api.revenuecat.com/v2",
+    automaticRateLimit: false,
+};
+function createRevenueCatClient(accessToken, options) {
+    if (!accessToken) {
+        // For non-TS users, we'll throw an error if the accessToken is not provided
+        throw new Error("accessToken is required");
+    }
+    const { automaticRateLimit, headers, ...otherOptions } = {
+        ...defaultOptions,
+        ...options,
+    };
+    const client = (0, openapi_fetch_1.default)({
+        ...otherOptions,
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            ...headers,
+        },
+    });
+    const pathBasedClient = (0, openapi_fetch_1.wrapAsPathBasedClient)(client);
+    if (automaticRateLimit) {
+        client.use((0, rateLimitMiddleware_1.createRateLimitMiddleware)());
+    }
+    return pathBasedClient;
+}

package/dist/rateLimitMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { Middleware } from "openapi-fetch";
+export declare const createRateLimitMiddleware: () => Middleware;
+//# sourceMappingURL=rateLimitMiddleware.d.ts.map

package/dist/rateLimitMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimitMiddleware.d.ts","sourceRoot":"","sources":["../src/rateLimitMiddleware.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAoM3C,eAAO,MAAM,yBAAyB,QAAO,UAuB5C,CAAC"}

package/dist/rateLimitMiddleware.js

@@ -0,0 +1,160 @@
+"use strict";
+// https://www.revenuecat.com/docs/api-v2#tag/Rate-Limit
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRateLimitMiddleware = void 0;
+class RateLimitManager {
+    async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    endpointStates = new Map();
+    maxRetries = 3;
+    maxQueueSize = 100;
+    getEndpointKey(request) {
+        const url = new URL(request.url);
+        return `${request.method}:${url.pathname}`;
+    }
+    getRetryAfterTime(response) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds)) {
+                return seconds;
+            }
+        }
+        // Fallback to 1 second if no valid Retry-After header
+        return 1;
+    }
+    async isRetryable(response) {
+        try {
+            // Clone the response to avoid consuming the body
+            const clonedResponse = response.clone();
+            const body = await clonedResponse.json();
+            // Check if retryable field exists and is false
+            if (typeof body === "object" && body !== null && "retryable" in body) {
+                return body.retryable !== false;
+            }
+            // Default to retryable if no retryable field is present
+            return true;
+        }
+        catch {
+            // If we can't parse the JSON, default to retryable
+            return true;
+        }
+    }
+    async waitForThrottle(request) {
+        const endpointKey = this.getEndpointKey(request);
+        // Initialize endpoint state if it doesn't exist
+        if (!this.endpointStates.has(endpointKey)) {
+            this.endpointStates.set(endpointKey, {
+                isThrottled: false,
+                retryAfter: 0,
+                queue: [],
+                lastRetryTime: 0,
+                processing: false,
+            });
+        }
+        const state = this.endpointStates.get(endpointKey);
+        // If throttled, wait for the retry-after time
+        if (state.isThrottled) {
+            const now = Date.now();
+            const waitTime = state.lastRetryTime + state.retryAfter * 1000 - now;
+            if (waitTime > 0) {
+                await this.delay(waitTime);
+            }
+            state.isThrottled = false;
+        }
+    }
+    async handleResponse(request, response) {
+        if (response.status !== 429) {
+            return response;
+        }
+        // Check if the response indicates it's not retryable
+        const shouldRetry = await this.isRetryable(response);
+        if (!shouldRetry) {
+            // If not retryable, return the original response immediately
+            return response;
+        }
+        const endpointKey = this.getEndpointKey(request);
+        // Initialize endpoint state if it doesn't exist
+        if (!this.endpointStates.has(endpointKey)) {
+            this.endpointStates.set(endpointKey, {
+                isThrottled: false,
+                retryAfter: 0,
+                queue: [],
+                lastRetryTime: 0,
+                processing: false,
+            });
+        }
+        const state = this.endpointStates.get(endpointKey);
+        let retryAfter = this.getRetryAfterTime(response);
+        state.isThrottled = true;
+        state.retryAfter = retryAfter;
+        state.lastRetryTime = Date.now();
+        let lastResponse = response;
+        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+            // Wait for the retry-after time
+            await this.delay(retryAfter * 1000);
+            try {
+                const retryResponse = await fetch(request, {});
+                if (retryResponse.status !== 429) {
+                    // Success, clear throttled state and return
+                    state.isThrottled = false;
+                    return retryResponse;
+                }
+                // Check if the retry response is also not retryable
+                const shouldRetryAgain = await this.isRetryable(retryResponse);
+                if (!shouldRetryAgain) {
+                    // If not retryable, return the response immediately
+                    state.isThrottled = false;
+                    return retryResponse;
+                }
+                // If still 429, update retryAfter for next attempt
+                retryAfter = this.getRetryAfterTime(retryResponse);
+                state.retryAfter = retryAfter;
+                state.lastRetryTime = Date.now();
+                lastResponse = retryResponse;
+            }
+            catch (error) {
+                // If fetch fails, throw the error
+                state.isThrottled = false;
+                throw error;
+            }
+        }
+        // All retries exhausted, return the last 429 response
+        state.isThrottled = false;
+        return lastResponse;
+    }
+    getQueueSize(request) {
+        const endpointKey = this.getEndpointKey(request);
+        const state = this.endpointStates.get(endpointKey);
+        return state?.queue.length || 0;
+    }
+    warnIfQueueTooLarge(request) {
+        const queueSize = this.getQueueSize(request);
+        if (queueSize >= this.maxQueueSize) {
+            const endpointKey = this.getEndpointKey(request);
+            console.warn(`[RevenueCat API] Rate limit queue for ${endpointKey} has reached maximum size of ${this.maxQueueSize}. Consider implementing additional throttling.`);
+        }
+    }
+}
+const createRateLimitMiddleware = () => {
+    const rateLimitManager = new RateLimitManager();
+    return {
+        async onRequest({ request }) {
+            // Wait if the endpoint is currently throttled
+            await rateLimitManager.waitForThrottle(request);
+            // Warn if queue is getting too large
+            rateLimitManager.warnIfQueueTooLarge(request);
+            // Don't return anything - let the request proceed normally
+            return undefined;
+        },
+        async onResponse({ request, response }) {
+            // Handle 429 responses with retry logic
+            if (response.status === 429) {
+                return await rateLimitManager.handleResponse(request, response);
+            }
+            return undefined;
+        },
+    };
+};
+exports.createRateLimitMiddleware = createRateLimitMiddleware;

package/eslint.config.mjs

@@ -0,0 +1,11 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+
+export default defineConfig([
+  { files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], plugins: { js }, extends: ["js/recommended"] },
+  { files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], languageOptions: { globals: globals.node } },
+  tseslint.configs.recommended,
+]);

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "revenuecat-api",
+  "version": "1.0.2",
+  "description": "Type-safe RevenueCat API client using fetch with automatic rate limiting",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "revenuecat",
+    "revenue-cat",
+    "api",
+    "client",
+    "fetch",
+    "rate-limiting"
+  ],
+  "author": "David Idol",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/idolize/revenuecat-api.git"
+  },
+  "dependencies": {
+    "openapi-fetch": "^0.14.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.30.1",
+    "@types/node": "^24.0.13",
+    "eslint": "^9.30.1",
+    "globals": "^16.3.0",
+    "openapi-typescript": "^7.8.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.36.0",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "test": "vitest --no-watch",
+    "test:watch": "vitest",
+    "types:check": "tsc --noEmit",
+    "lint": "eslint ./src/**",
+    "lint:fix": "eslint ./src/** --fix",
+    "update:openapi": "rm downloaded/openapi.yaml && pnpm generate:openapi",
+    "generate:openapi": "scripts/generate_openapi_client.sh"
+  }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+onlyBuiltDependencies:
+  - msw

package/scripts/generate_openapi_client.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+OPENAPI_FILE="./downloaded/openapi.yaml"
+
+if [ ! -f "$OPENAPI_FILE" ]; then
+  curl -o "$OPENAPI_FILE" https://www.revenuecat.com/docs/redocusaurus/plugin-redoc-0.yaml
+fi
+
+npx openapi-typescript "$OPENAPI_FILE" -o ./src/__generated/revenuecat-api-v2.d.ts