@superwall/server 0.2.0 → 0.2.1

package/.turbo/turbo-test.log

@@ -1,73 +0,0 @@
-$ bun test
-bun test v1.3.11 (af24e281)
-
-src/requires.test.ts:
-(pass) sw.requires() > calls next() when entitled [1.40ms]
-(pass) sw.requires() > default 403 when not entitled [0.13ms]
-(pass) sw.requires() > fail-closed when no userId can be extracted [0.06ms]
-(pass) sw.requires() > allowAnonymous lets the handler decide [0.05ms]
-(pass) sw.requires() > onUnauthorized override [1.02ms]
-(pass) sw.requires() > per-route userId override wins [0.24ms]
-(pass) sw.requires() > network errors pass to next(err) [0.14ms]
-(pass) sw.requires() > multiple-AND spec rejects when any missing [0.07ms]
-(pass) sw.requires() > ANY spec passes when one active [0.06ms]
-(pass) sw.requires() > normalizes spec at registration time (fails loud) [0.04ms]
-
-src/cache.test.ts:
-(pass) InMemoryCache > get returns null on miss
-(pass) InMemoryCache > set + get returns the entry [0.08ms]
-(pass) InMemoryCache > expired entry is dropped on read [0.04ms]
-(pass) InMemoryCache > delete removes the entry [0.03ms]
-(pass) InMemoryCache > clear empties the cache [0.03ms]
-(pass) InMemoryCache > LRU evicts oldest when maxEntries exceeded [0.12ms]
-(pass) InMemoryCache > read refreshes LRU position so recent reads survive eviction [0.04ms]
-
-src/superwall.test.ts:
-(pass) Superwall() factory > rejects missing apiKey [0.06ms]
-(pass) Superwall() factory > getEntitlements returns parsed bucket [0.29ms]
-(pass) Superwall() factory > userHas (string) returns true when entitlement is active [0.06ms]
-(pass) Superwall() factory > userHas (string) returns false when entitlement is inactive
-(pass) Superwall() factory > userHas (array) requires all [0.15ms]
-(pass) Superwall() factory > userHas ({ any }) returns true when any active [0.11ms]
-(pass) Superwall() factory > caches subsequent reads for the same userId [0.05ms]
-(pass) Superwall() factory > invalidate forces a refetch [0.09ms]
-(pass) Superwall() factory > invalidateAll clears every entry [0.09ms]
-(pass) Superwall() factory > TTL expiry forces a refetch [5.91ms]
-(pass) Superwall() factory > onRequest fires with cache hit info [0.15ms]
-(pass) Superwall() factory > onRequest throwing does not break the request [0.07ms]
-
-src/fetcher.test.ts:
-(pass) fetchEntitlements > parses customerInfo.entitlements envelope [0.28ms]
-(pass) fetchEntitlements > parses top-level entitlements array [0.10ms]
-(pass) fetchEntitlements > encodes the userId in the URL path [0.16ms]
-(pass) fetchEntitlements > includes Authorization and X-App-User-ID headers [0.25ms]
-(pass) fetchEntitlements > 401 → SuperwallAuthError [0.14ms]
-(pass) fetchEntitlements > 403 → SuperwallAuthError [0.10ms]
-(pass) fetchEntitlements > 404 → SuperwallNotFoundError [0.07ms]
-(pass) fetchEntitlements > 500 → SuperwallNetworkError with status [0.13ms]
-(pass) fetchEntitlements > fetch throw → SuperwallNetworkError [0.12ms]
-(pass) fetchEntitlements > AbortError → SuperwallTimeoutError [6.50ms]
-(pass) fetchEntitlements > malformed JSON → SuperwallDecodingError [0.16ms]
-(pass) fetchEntitlements > uses the configured environment for the host [0.05ms]
-
-src/spec.test.ts:
-(pass) normalizeSpec > string [0.02ms]
-(pass) normalizeSpec > array → all
-(pass) normalizeSpec > { all } [0.02ms]
-(pass) normalizeSpec > { any } [0.02ms]
-(pass) normalizeSpec > rejects empty string [0.03ms]
-(pass) normalizeSpec > rejects empty array [0.03ms]
-(pass) normalizeSpec > rejects empty all [0.02ms]
-(pass) normalizeSpec > rejects empty any [0.02ms]
-(pass) normalizeSpec > rejects malformed object [0.04ms]
-(pass) findMissing (mode: all) > returns empty when all entitlements active [0.07ms]
-(pass) findMissing (mode: all) > returns the missing entitlement
-(pass) findMissing (mode: all) > ignores extra active entitlements [0.03ms]
-(pass) findMissing (mode: all) > inactive entitlements are not counted [0.03ms]
-(pass) findMissing (mode: any) > returns empty when any one is active [0.03ms]
-(pass) findMissing (mode: any) > returns all listed when none active [0.02ms]
-
- 56 pass
- 0 fail
- 84 expect() calls
-Ran 56 tests across 5 files. [42.00ms]

package/.turbo/turbo-typecheck.log

@@ -1 +0,0 @@
-$ tsc --noEmit

package/src/cache.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { InMemoryCache } from "./cache.ts";
-import type { CacheEntry } from "./types.ts";
-
-const entry = (id: string, expiresAt: number): CacheEntry => ({
-  expiresAt,
-  value: {
-    active: [{ id, type: "SERVICE_LEVEL", isActive: true, productIds: [] }],
-    inactive: [],
-    all: [{ id, type: "SERVICE_LEVEL", isActive: true, productIds: [] }],
-  },
-});
-
-describe("InMemoryCache", () => {
-  test("get returns null on miss", () => {
-    const c = new InMemoryCache(10);
-    expect(c.get("nope")).toBeNull();
-  });
-
-  test("set + get returns the entry", () => {
-    const c = new InMemoryCache(10);
-    const e = entry("pro", Date.now() + 1000);
-    c.set("u1", e);
-    expect(c.get("u1")).toBe(e);
-  });
-
-  test("expired entry is dropped on read", () => {
-    const c = new InMemoryCache(10);
-    c.set("u1", entry("pro", Date.now() - 1));
-    expect(c.get("u1")).toBeNull();
-    expect(c.size).toBe(0);
-  });
-
-  test("delete removes the entry", () => {
-    const c = new InMemoryCache(10);
-    c.set("u1", entry("pro", Date.now() + 1000));
-    c.delete("u1");
-    expect(c.get("u1")).toBeNull();
-  });
-
-  test("clear empties the cache", () => {
-    const c = new InMemoryCache(10);
-    c.set("a", entry("pro", Date.now() + 1000));
-    c.set("b", entry("pro", Date.now() + 1000));
-    c.clear();
-    expect(c.size).toBe(0);
-  });
-
-  test("LRU evicts oldest when maxEntries exceeded", () => {
-    const c = new InMemoryCache(2);
-    c.set("a", entry("pro", Date.now() + 1000));
-    c.set("b", entry("pro", Date.now() + 1000));
-    c.set("c", entry("pro", Date.now() + 1000));
-    expect(c.size).toBe(2);
-    expect(c.get("a")).toBeNull();
-    expect(c.get("b")).not.toBeNull();
-    expect(c.get("c")).not.toBeNull();
-  });
-
-  test("read refreshes LRU position so recent reads survive eviction", () => {
-    const c = new InMemoryCache(2);
-    c.set("a", entry("pro", Date.now() + 1000));
-    c.set("b", entry("pro", Date.now() + 1000));
-    c.get("a"); // refresh
-    c.set("c", entry("pro", Date.now() + 1000));
-    expect(c.get("a")).not.toBeNull();
-    expect(c.get("b")).toBeNull();
-    expect(c.get("c")).not.toBeNull();
-  });
-});

package/src/cache.ts

@@ -1,53 +0,0 @@
-import type { CacheAdapter, CacheEntry } from "./types.ts";
-
-/**
- * In-memory LRU cache. Entries are evicted (a) on TTL expiry when read,
- * and (b) when the map exceeds `maxEntries` (oldest-insertion-order first).
- *
- * Single-process only. For multi-instance deployments, supply a Redis or
- * KV adapter via `cache.storage`.
- */
-export class InMemoryCache implements CacheAdapter {
-  readonly #map = new Map<string, CacheEntry>();
-  readonly #maxEntries: number;
-
-  constructor(maxEntries: number) {
-    this.#maxEntries = maxEntries;
-  }
-
-  get(key: string): CacheEntry | null {
-    const entry = this.#map.get(key);
-    if (!entry) return null;
-    if (entry.expiresAt <= Date.now()) {
-      this.#map.delete(key);
-      return null;
-    }
-    // Refresh LRU position — re-insert moves to the end.
-    this.#map.delete(key);
-    this.#map.set(key, entry);
-    return entry;
-  }
-
-  set(key: string, value: CacheEntry): void {
-    if (this.#map.has(key)) this.#map.delete(key);
-    this.#map.set(key, value);
-    while (this.#map.size > this.#maxEntries) {
-      const oldest = this.#map.keys().next().value;
-      if (oldest === undefined) break;
-      this.#map.delete(oldest);
-    }
-  }
-
-  delete(key: string): void {
-    this.#map.delete(key);
-  }
-
-  clear(): void {
-    this.#map.clear();
-  }
-
-  // Test helper — current size.
-  get size(): number {
-    return this.#map.size;
-  }
-}

package/src/fetcher.test.ts

@@ -1,183 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import {
-  SuperwallAuthError,
-  SuperwallDecodingError,
-  SuperwallNetworkError,
-  SuperwallNotFoundError,
-  SuperwallTimeoutError,
-} from "@superwall/core";
-import { fetchEntitlements, type FetcherConfig } from "./fetcher.ts";
-import type { FetchLike } from "./types.ts";
-
-const realFetch = globalThis.fetch;
-const setFetch = (impl: FetchLike): void => {
-  (globalThis as unknown as { fetch: FetchLike }).fetch = impl;
-};
-
-interface MockResponseInit {
-  status?: number;
-  json?: unknown;
-  jsonThrows?: boolean;
-}
-
-const mockResponse = (init: MockResponseInit = {}): Response => {
-  const status = init.status ?? 200;
-  const body: string | null =
-    init.json !== undefined ? JSON.stringify(init.json) : null;
-  const res = new Response(body, {
-    status,
-    headers: { "content-type": "application/json" },
-  });
-  if (init.jsonThrows) {
-    Object.defineProperty(res, "json", {
-      value: () => Promise.reject(new SyntaxError("bad json")),
-    });
-  }
-  return res;
-};
-
-const baseConfig = (overrides: Partial<FetcherConfig> = {}): FetcherConfig => ({
-  apiKey: "key_test",
-  environment: "release",
-  timeoutMs: 1000,
-  ...overrides,
-});
-
-const urlOf = (input: string | URL | Request): string =>
-  typeof input === "string"
-    ? input
-    : input instanceof URL
-      ? input.toString()
-      : input.url;
-
-afterEach(() => {
-  (globalThis as unknown as { fetch: typeof realFetch }).fetch = realFetch;
-});
-
-describe("fetchEntitlements", () => {
-  test("parses customerInfo.entitlements envelope", async () => {
-    setFetch(async () =>
-      mockResponse({
-        json: {
-          customerInfo: {
-            entitlements: [
-              { id: "pro", isActive: true, productIds: ["p1"] },
-              { id: "team", isActive: false, productIds: [] },
-            ],
-          },
-        },
-      }),
-    );
-    const ents = await fetchEntitlements(baseConfig(), "user_1");
-    expect(ents.active.map((e) => e.id)).toEqual(["pro"]);
-    expect(ents.inactive.map((e) => e.id)).toEqual(["team"]);
-    expect(ents.all).toHaveLength(2);
-  });
-
-  test("parses top-level entitlements array", async () => {
-    setFetch(async () =>
-      mockResponse({
-        json: {
-          entitlements: [{ id: "pro", isActive: true, productIds: [] }],
-        },
-      }),
-    );
-    const ents = await fetchEntitlements(baseConfig(), "user_1");
-    expect(ents.active.map((e) => e.id)).toEqual(["pro"]);
-  });
-
-  test("encodes the userId in the URL path", async () => {
-    let calledUrl = "";
-    setFetch(async (input) => {
-      calledUrl = urlOf(input);
-      return mockResponse({ json: { entitlements: [] } });
-    });
-    await fetchEntitlements(baseConfig(), "user/special:1");
-    expect(calledUrl).toContain("/users/user%2Fspecial%3A1/entitlements");
-  });
-
-  test("includes Authorization and X-App-User-ID headers", async () => {
-    let calledHeaders: Headers | null = null;
-    setFetch(async (_input, init) => {
-      calledHeaders = new Headers(init?.headers);
-      return mockResponse({ json: { entitlements: [] } });
-    });
-    await fetchEntitlements(baseConfig(), "user_1");
-    expect(calledHeaders!.get("authorization")).toBe("Bearer key_test");
-    expect(calledHeaders!.get("x-app-user-id")).toBe("user_1");
-    expect(calledHeaders!.get("x-platform")).toBe("Server");
-  });
-
-  test("401 → SuperwallAuthError", async () => {
-    setFetch(async () => mockResponse({ status: 401 }));
-    await expect(fetchEntitlements(baseConfig(), "u")).rejects.toBeInstanceOf(
-      SuperwallAuthError,
-    );
-  });
-
-  test("403 → SuperwallAuthError", async () => {
-    setFetch(async () => mockResponse({ status: 403 }));
-    await expect(fetchEntitlements(baseConfig(), "u")).rejects.toBeInstanceOf(
-      SuperwallAuthError,
-    );
-  });
-
-  test("404 → SuperwallNotFoundError", async () => {
-    setFetch(async () => mockResponse({ status: 404 }));
-    await expect(fetchEntitlements(baseConfig(), "u")).rejects.toBeInstanceOf(
-      SuperwallNotFoundError,
-    );
-  });
-
-  test("500 → SuperwallNetworkError with status", async () => {
-    setFetch(async () => mockResponse({ status: 500 }));
-    try {
-      await fetchEntitlements(baseConfig(), "u");
-      throw new Error("should have thrown");
-    } catch (err) {
-      expect(err).toBeInstanceOf(SuperwallNetworkError);
-      expect((err as SuperwallNetworkError).status).toBe(500);
-    }
-  });
-
-  test("fetch throw → SuperwallNetworkError", async () => {
-    setFetch(async () => {
-      throw new Error("ECONNREFUSED");
-    });
-    await expect(fetchEntitlements(baseConfig(), "u")).rejects.toBeInstanceOf(
-      SuperwallNetworkError,
-    );
-  });
-
-  test("AbortError → SuperwallTimeoutError", async () => {
-    setFetch(async (_input, init) => {
-      return new Promise<Response>((_resolve, reject) => {
-        init?.signal?.addEventListener("abort", () => {
-          const err = new Error("aborted");
-          err.name = "AbortError";
-          reject(err);
-        });
-      });
-    });
-    await expect(
-      fetchEntitlements(baseConfig({ timeoutMs: 5 }), "u"),
-    ).rejects.toBeInstanceOf(SuperwallTimeoutError);
-  });
-
-  test("malformed JSON → SuperwallDecodingError", async () => {
-    setFetch(async () => mockResponse({ jsonThrows: true }));
-    await expect(fetchEntitlements(baseConfig(), "u")).rejects.toBeInstanceOf(
-      SuperwallDecodingError,
-    );
-  });
-
-  test("uses the configured environment for the host", async () => {
-    let calledUrl = "";
-    setFetch(async (input) => {
-      calledUrl = urlOf(input);
-      return mockResponse({ json: { entitlements: [] } });
-    });
-    await fetchEntitlements(baseConfig({ environment: "developer" }), "u");
-    expect(calledUrl).toContain("subscriptions-api.superwall.dev");
-  });
-});

package/src/fetcher.ts

@@ -1,116 +0,0 @@
-import {
-  parseEntitlements,
-  resolveHosts,
-  SuperwallAuthError,
-  SuperwallDecodingError,
-  SuperwallNetworkError,
-  SuperwallNotFoundError,
-  SuperwallTimeoutError,
-  type Entitlements,
-  type NetworkEnvironment,
-  type WebEntitlementsResponse,
-} from "@superwall/core";
-import type { FetchLike } from "./types.ts";
-
-const SDK_VERSION = "0.0.0";
-
-export interface FetcherConfig {
-  readonly apiKey: string;
-  readonly environment: NetworkEnvironment;
-  readonly timeoutMs: number;
-}
-
-const requireFetch = (): FetchLike => {
-  if (typeof globalThis !== "undefined" && "fetch" in globalThis) {
-    return globalThis.fetch.bind(globalThis) as FetchLike;
-  }
-  throw new SuperwallNetworkError(
-    "No fetch implementation available — Superwall needs `globalThis.fetch` (Node 18+, Bun, Deno, Workers).",
-  );
-};
-
-/**
- * GET /subscriptions-api/public/v1/users/{userId}/entitlements
- *
- * Maps status codes to typed error classes. Returns the parsed
- * Entitlements bucket on success.
- */
-export const fetchEntitlements = async (
-  cfg: FetcherConfig,
-  userId: string,
-): Promise<Entitlements> => {
-  const hosts = resolveHosts(cfg.environment);
-  const url = `https://${hosts.subscriptions}/subscriptions-api/public/v1/users/${encodeURIComponent(userId)}/entitlements`;
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${cfg.apiKey}`,
-    "Content-Type": "application/json",
-    "X-Platform": "Server",
-    "X-Platform-Environment": "SDK",
-    "X-Platform-Wrapper": "Server",
-    "X-SDK-Version": SDK_VERSION,
-    "X-App-User-ID": userId,
-  };
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
-
-  let response: Response;
-  try {
-    response = await requireFetch()(url, {
-      method: "GET",
-      headers,
-      signal: controller.signal,
-    });
-  } catch (cause) {
-    clearTimeout(timer);
-    if (cause instanceof Error && cause.name === "AbortError") {
-      throw new SuperwallTimeoutError(
-        `Entitlements request timed out after ${cfg.timeoutMs}ms`,
-        { url, timeoutMs: cfg.timeoutMs },
-      );
-    }
-    throw new SuperwallNetworkError(
-      `Entitlements network error: ${describe(cause)}`,
-      { url, cause },
-    );
-  }
-  clearTimeout(timer);
-
-  if (response.status === 401 || response.status === 403) {
-    throw new SuperwallAuthError(
-      `Entitlements auth failed (status ${response.status}). Check SUPERWALL_API_KEY.`,
-      { url },
-    );
-  }
-  if (response.status === 404) {
-    throw new SuperwallNotFoundError(
-      `Entitlements lookup returned 404 for user ${userId}.`,
-      { url },
-    );
-  }
-  if (!response.ok) {
-    throw new SuperwallNetworkError(
-      `Entitlements returned ${response.status}`,
-      { url, status: response.status },
-    );
-  }
-
-  let body: WebEntitlementsResponse;
-  try {
-    body = (await response.json()) as WebEntitlementsResponse;
-  } catch (cause) {
-    throw new SuperwallDecodingError(
-      `Entitlements JSON decode failed: ${describe(cause)}`,
-      { url, cause },
-    );
-  }
-
-  return parseEntitlements(body);
-};
-
-const describe = (cause: unknown): string =>
-  cause instanceof Error
-    ? cause.message
-    : typeof cause === "string"
-      ? cause
-      : JSON.stringify(cause);

package/src/index.ts

@@ -1,50 +0,0 @@
-// @superwall/server — server-side entitlement enforcement for the Superwall web SDK.
-//
-// Quickstart:
-//
-//   import { Superwall } from "@superwall/server"
-//
-//   const sw = Superwall({
-//     apiKey: process.env.SUPERWALL_API_KEY!,
-//     userId: (req) => req.session?.userId ?? null,
-//   })
-//
-//   app.get("/api/export", sw.requires("pro"), exportHandler)
-//
-// The browser SDK's local subscription state is writable from DevTools. This
-// package gates routes server-to-server against Superwall's `/entitlements`
-// endpoint so tampering with the client cannot grant access to real resources.
-
-export { Superwall } from "./superwall.ts";
-export type {
-  SuperwallOptions,
-  SuperwallInstance,
-  EntitlementSpec,
-  RequiresOptions,
-  UserIdExtractor,
-  CacheAdapter,
-  CacheOptions,
-  RequestInfo as OnRequestInfo,
-  UnauthorizedContext,
-  ConnectStyleRequest,
-  ConnectStyleResponse,
-  ConnectStyleNext,
-} from "./types.ts";
-
-// Re-export shared domain types so consumers don't need to also depend on @superwall/core.
-export type {
-  Entitlement,
-  Entitlements,
-  SubscriptionStatus,
-  NetworkEnvironment,
-  CustomEnvironmentHosts,
-} from "@superwall/core";
-
-export {
-  SuperwallError,
-  SuperwallNetworkError,
-  SuperwallAuthError,
-  SuperwallNotFoundError,
-  SuperwallTimeoutError,
-  SuperwallDecodingError,
-} from "@superwall/core";