@superwall/server 0.2.0 → 0.2.1

package/src/superwall.ts

@@ -1,121 +0,0 @@
-import type { Entitlements } from "@superwall/core";
-import { InMemoryCache } from "./cache.ts";
-import { fetchEntitlements, type FetcherConfig } from "./fetcher.ts";
-import { findMissing, normalizeSpec } from "./spec.ts";
-import { makeRequires } from "./requires.ts";
-import type {
-  CacheAdapter,
-  EntitlementSpec,
-  RequestInfo,
-  RequiresOptions,
-  SuperwallInstance,
-  SuperwallOptions,
-} from "./types.ts";
-
-const DEFAULT_CACHE_TTL_MS = 60_000;
-const DEFAULT_CACHE_MAX = 10_000;
-const DEFAULT_TIMEOUT_MS = 5_000;
-
-/**
- * Construct a Superwall server instance. One per process — internally
- * shares the cache and outbound HTTP config across all middleware and
- * direct calls.
- *
- * ```ts
- * const sw = Superwall({
- *   apiKey: process.env.SUPERWALL_API_KEY!,
- *   userId: (req) => req.session?.userId ?? null,
- * })
- * ```
- */
-export const Superwall = <TReq = unknown>(
-  options: SuperwallOptions<TReq>,
-): SuperwallInstance<TReq> => {
-  if (!options.apiKey || typeof options.apiKey !== "string") {
-    throw new TypeError("Superwall: `apiKey` is required.");
-  }
-
-  const cacheOpts = options.cache ?? {};
-  const ttlMs = cacheOpts.ttlMs ?? DEFAULT_CACHE_TTL_MS;
-  const maxEntries = cacheOpts.maxEntries ?? DEFAULT_CACHE_MAX;
-  const cache: CacheAdapter =
-    cacheOpts.storage === undefined || cacheOpts.storage === "memory"
-      ? new InMemoryCache(maxEntries)
-      : cacheOpts.storage;
-
-  const fetcherConfig: FetcherConfig = {
-    apiKey: options.apiKey,
-    environment: options.environment ?? "release",
-    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-  };
-
-  /** Fetch + cache for one userId. Inflight de-dup is intentionally
-   *  omitted for v0 — callers rarely concurrently lookup the same user
-   *  thousands of times, and the trade-off (extra closure per request)
-   *  isn't worth it before we measure. */
-  const loadEntitlements = async (userId: string): Promise<{
-    entitlements: Entitlements;
-    cacheHit: boolean;
-  }> => {
-    const cached = await cache.get(userId);
-    if (cached) return { entitlements: cached.value, cacheHit: true };
-    const ents = await fetchEntitlements(fetcherConfig, userId);
-    await cache.set(userId, { value: ents, expiresAt: Date.now() + ttlMs });
-    return { entitlements: ents, cacheHit: false };
-  };
-
-  const emitRequest = (info: RequestInfo): void => {
-    if (!options.onRequest) return;
-    try {
-      options.onRequest(info);
-    } catch {
-      // Telemetry hooks never break the request.
-    }
-  };
-
-  const getEntitlements = async (userId: string): Promise<Entitlements> => {
-    const start = Date.now();
-    const { entitlements, cacheHit } = await loadEntitlements(userId);
-    emitRequest({
-      userId,
-      entitlements: entitlements.active.map((e) => e.id),
-      cacheHit,
-      durationMs: Date.now() - start,
-    });
-    return entitlements;
-  };
-
-  const userHas = async (
-    userId: string,
-    spec: EntitlementSpec,
-  ): Promise<boolean> => {
-    const normalized = normalizeSpec(spec);
-    const ents = await getEntitlements(userId);
-    return findMissing(normalized, ents).length === 0;
-  };
-
-  const invalidate = async (userId: string): Promise<void> => {
-    await cache.delete(userId);
-  };
-
-  const invalidateAll = async (): Promise<void> => {
-    await cache.clear();
-  };
-
-  const requires = makeRequires<TReq>({
-    defaultUserIdExtractor: options.userId,
-    loadEntitlements,
-    emitRequest,
-  });
-
-  return {
-    requires,
-    userHas,
-    getEntitlements,
-    invalidate,
-    invalidateAll,
-  };
-};
-
-// Re-export for tests that need to construct fetcher config directly.
-export type { FetcherConfig };

package/src/types.ts

@@ -1,137 +0,0 @@
-import type { Entitlements, NetworkEnvironment } from "@superwall/core";
-
-/**
- * Entitlement spec accepted by `sw.requires()` and `sw.userHas()`.
- *
- * - `"pro"` — single entitlement (must be active)
- * - `["pro", "team"]` — multiple entitlements, ALL required
- * - `{ all: [...] }` — explicit AND
- * - `{ any: [...] }` — OR (any of the listed must be active)
- */
-export type EntitlementSpec =
-  | string
-  | ReadonlyArray<string>
-  | { readonly all: ReadonlyArray<string> }
-  | { readonly any: ReadonlyArray<string> };
-
-/**
- * Cache adapter shape. The built-in `"memory"` storage implements this.
- * Plug in Redis, KV, or any async store with the same surface.
- *
- * Keys are app-user IDs. Values are the parsed Entitlements bucket plus
- * the timestamp it expires at.
- */
-export interface CacheAdapter {
-  get(key: string): Promise<CacheEntry | null> | CacheEntry | null;
-  set(key: string, value: CacheEntry): Promise<void> | void;
-  delete(key: string): Promise<void> | void;
-  clear(): Promise<void> | void;
-}
-
-export interface CacheEntry {
-  readonly value: Entitlements;
-  readonly expiresAt: number;
-}
-
-export interface CacheOptions {
-  /** Time-to-live in milliseconds. Default 60_000 (60s). */
-  ttlMs?: number;
-  /** LRU cap; oldest evicted first. Default 10_000. */
-  maxEntries?: number;
-  /** `"memory"` or a custom adapter. Default `"memory"`. */
-  storage?: "memory" | CacheAdapter;
-}
-
-/**
- * Extracts the user identifier from whatever request shape your framework
- * uses. Safety-critical knob: read from authenticated session, never from
- * request body / query string / unverified header.
- */
-export type UserIdExtractor<TReq = unknown> = (
-  req: TReq,
-) => string | null | undefined | Promise<string | null | undefined>;
-
-export interface RequestInfo {
-  readonly userId: string;
-  readonly entitlements: ReadonlyArray<string>;
-  readonly cacheHit: boolean;
-  readonly durationMs: number;
-}
-
-export interface SuperwallOptions<TReq = unknown> {
-  /** Superwall API key. Read from `process.env.SUPERWALL_API_KEY`. */
-  apiKey: string;
-  /** Environment selector. Default `"release"`. */
-  environment?: NetworkEnvironment;
-  cache?: CacheOptions;
-  /** Default userId extractor; can be overridden per-call on `requires()`. */
-  userId?: UserIdExtractor<TReq>;
-  /** Hook invoked after every entitlement check. Use for tracing. */
-  onRequest?: (info: RequestInfo) => void;
-  /** Request timeout in milliseconds for outbound calls to Superwall. Default 5_000. */
-  timeoutMs?: number;
-}
-
-/**
- * Narrow internal `fetch` surface. Not exported as a public option — server
- * runtimes (Node 18+, Bun, Deno, Workers) all carry `globalThis.fetch`
- * natively, and unlike the browser there's no CORS proxy use case. Tests
- * stub `globalThis.fetch` directly.
- */
-export type FetchLike = (
-  input: string | URL | Request,
-  init?: RequestInit,
-) => Promise<Response>;
-
-// Connect-style middleware signature — req/res/next, duck-typed. Compatible
-// with Express, Connect, and shimmable from Bun.serve / Hono / Next.
-
-export interface ConnectStyleResponse {
-  status(code: number): ConnectStyleResponse;
-  json(body: unknown): unknown;
-  setHeader?(name: string, value: string): unknown;
-}
-
-export type ConnectStyleNext = (err?: unknown) => void;
-
-export type ConnectStyleRequest = Record<string, unknown>;
-
-export interface UnauthorizedContext {
-  readonly userId: string | null;
-  readonly entitlement: string;
-  readonly missing: ReadonlyArray<string>;
-  readonly reason: "no_user_id" | "not_entitled";
-}
-
-export interface RequiresOptions<TReq = unknown> {
-  /** Per-route userId override (rare). */
-  userId?: UserIdExtractor<TReq>;
-  /**
-   * Custom rejection handler. Default: respond `403 { error:
-   * "entitlement_required", entitlement }`.
-   */
-  onUnauthorized?: (
-    req: TReq,
-    res: ConnectStyleResponse,
-    ctx: UnauthorizedContext,
-  ) => void | Promise<void>;
-  /**
-   * Allow anonymous requests (no userId extracted) to fall through to the
-   * route handler. Defaults to `false` — fail closed. Set `true` when the
-   * route handler itself decides what to render for guests vs. entitled users.
-   */
-  allowAnonymous?: boolean;
-}
-
-// The object returned by Superwall(options). Methods bind back to the
-// shared cache + fetcher so a single instance fronts the entire process.
-export interface SuperwallInstance<TReq = unknown> {
-  requires(
-    spec: EntitlementSpec,
-    options?: RequiresOptions<TReq>,
-  ): (req: TReq, res: ConnectStyleResponse, next: ConnectStyleNext) => Promise<void>;
-  userHas(userId: string, spec: EntitlementSpec): Promise<boolean>;
-  getEntitlements(userId: string): Promise<Entitlements>;
-  invalidate(userId: string): Promise<void>;
-  invalidateAll(): Promise<void>;
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src"
-  },
-  "include": ["src/**/*"]
-}