@dream-api/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,599 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DreamAPI: () => DreamAPI,
+  DreamAPIException: () => DreamAPIException,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var DreamAPIException = class extends Error {
+  constructor(error, status = 500) {
+    super(error.message);
+    this.name = "DreamAPIException";
+    this.status = status;
+    this.code = error.error;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api-multi.k-c-sheffield012376.workers.dev";
+var DEFAULT_SIGNUP_URL = "https://sign-up.k-c-sheffield012376.workers.dev";
+var DEFAULT_CLERK_URL = "https://composed-blowfish-76.accounts.dev";
+var DreamClient = class {
+  constructor(config) {
+    this.userToken = null;
+    this.tokenRefresher = null;
+    if (!config.secretKey) {
+      throw new Error("DreamAPI: secretKey is required");
+    }
+    this.secretKey = config.secretKey;
+    this.publishableKey = config.publishableKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.signupUrl = config.signupUrl || DEFAULT_SIGNUP_URL;
+    this.clerkUrl = config.clerkBaseUrl || DEFAULT_CLERK_URL;
+  }
+  /**
+   * Set the end-user JWT token for user-specific operations.
+   * Call this after the user signs in via Clerk.
+   */
+  setUserToken(token) {
+    this.userToken = token;
+  }
+  /**
+   * Clear the current user token (on sign out)
+   */
+  clearUserToken() {
+    this.userToken = null;
+  }
+  /**
+   * Set a function to refresh the token before API calls
+   */
+  setTokenRefresher(refresher) {
+    this.tokenRefresher = refresher;
+  }
+  /**
+   * Refresh token if we have a refresher set
+   */
+  async ensureFreshToken() {
+    if (this.tokenRefresher) {
+      const newToken = await this.tokenRefresher();
+      if (newToken) {
+        this.userToken = newToken;
+      }
+    }
+  }
+  /**
+   * Get the publishable key
+   */
+  getPublishableKey() {
+    return this.publishableKey;
+  }
+  /**
+   * Get the sign-up URL base
+   */
+  getSignupBaseUrl() {
+    return this.signupUrl;
+  }
+  /**
+   * Get the Clerk base URL for hosted auth pages
+   */
+  getClerkBaseUrl() {
+    return this.clerkUrl;
+  }
+  /**
+   * Make an authenticated request to the API
+   */
+  async request(method, endpoint, options = {}) {
+    const { body, requiresUserToken = false } = options;
+    const headers = {
+      "Authorization": `Bearer ${this.secretKey}`,
+      "Content-Type": "application/json"
+    };
+    if (this.publishableKey) {
+      headers["X-Publishable-Key"] = this.publishableKey;
+    }
+    if (requiresUserToken) {
+      if (!this.userToken) {
+        throw new DreamAPIException(
+          { error: "auth_required", message: "User token required. Call setUserToken() first." },
+          401
+        );
+      }
+      headers["X-Clerk-Token"] = this.userToken;
+    } else if (this.userToken) {
+      headers["X-Clerk-Token"] = this.userToken;
+    }
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      const error = data;
+      throw new DreamAPIException(error, response.status);
+    }
+    return data;
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, requiresUserToken = false) {
+    return this.request("GET", endpoint, { requiresUserToken });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body, requiresUserToken = false) {
+    return this.request("POST", endpoint, { body, requiresUserToken });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, body, requiresUserToken = false) {
+    return this.request("PATCH", endpoint, { body, requiresUserToken });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint, requiresUserToken = false) {
+    return this.request("DELETE", endpoint, { requiresUserToken });
+  }
+};
+
+// src/clerk.ts
+var CLERK_PUBLISHABLE_KEY = "pk_test_Y29tcG9zZWQtYmxvd2Zpc2gtNzYuY2xlcmsuYWNjb3VudHMuZGV2JA";
+var CLERK_CDN_URL = "https://cdn.jsdelivr.net/npm/@clerk/clerk-js@5/dist/clerk.browser.js";
+var JWT_TEMPLATE = "end-user-api";
+function getClerk() {
+  return window.Clerk;
+}
+var ClerkManager = class {
+  constructor(onTokenChange) {
+    this.loaded = false;
+    this.token = null;
+    this.onTokenChange = onTokenChange;
+  }
+  /**
+   * Load Clerk SDK (call once on page load)
+   */
+  async load() {
+    if (this.loaded || typeof window === "undefined") return;
+    const existingClerk = getClerk();
+    if (existingClerk) {
+      this.loaded = true;
+      await this.checkSession();
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = CLERK_CDN_URL;
+      script.async = true;
+      script.crossOrigin = "anonymous";
+      script.setAttribute("data-clerk-publishable-key", CLERK_PUBLISHABLE_KEY);
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error("Failed to load Clerk SDK"));
+      document.head.appendChild(script);
+    });
+    const clerk = getClerk();
+    if (clerk) {
+      await clerk.load();
+    }
+    this.loaded = true;
+    await this.checkSession();
+  }
+  /**
+   * Check if returning from auth and grab token
+   */
+  async checkSession() {
+    const clerk = getClerk();
+    if (!clerk?.session || !clerk?.user) {
+      return;
+    }
+    try {
+      this.token = await clerk.session.getToken({ template: JWT_TEMPLATE });
+      this.onTokenChange?.(this.token);
+    } catch (err) {
+      console.error("Failed to get Clerk token:", err);
+    }
+  }
+  /**
+   * Check if user is signed in
+   */
+  isSignedIn() {
+    const clerk = getClerk();
+    return !!clerk?.user && !!clerk?.session;
+  }
+  /**
+   * Get current user info
+   */
+  getUser() {
+    const clerk = getClerk();
+    if (!clerk?.user) return null;
+    const user = clerk.user;
+    const metadata = user.publicMetadata || {};
+    return {
+      id: user.id,
+      email: user.primaryEmailAddress?.emailAddress || "",
+      plan: metadata.plan || "free",
+      publishableKey: metadata.publishableKey || ""
+    };
+  }
+  /**
+   * Get current token
+   */
+  getToken() {
+    return this.token;
+  }
+  /**
+   * Refresh token (call before API requests)
+   */
+  async refreshToken() {
+    const clerk = getClerk();
+    if (!clerk?.session) return null;
+    try {
+      this.token = await clerk.session.getToken({ template: JWT_TEMPLATE });
+      this.onTokenChange?.(this.token);
+      return this.token;
+    } catch (err) {
+      console.error("Failed to refresh token:", err);
+      return null;
+    }
+  }
+  /**
+   * Sign out
+   */
+  async signOut() {
+    const clerk = getClerk();
+    if (!clerk) return;
+    await clerk.signOut();
+    this.token = null;
+    this.onTokenChange?.(null);
+  }
+  /**
+   * Check if we're returning from auth (has clerk params/cookies)
+   */
+  static hasAuthParams() {
+    if (typeof window === "undefined") return false;
+    return window.location.search.includes("__clerk") || document.cookie.includes("__clerk") || document.cookie.includes("__session");
+  }
+};
+
+// src/auth.ts
+var AuthHelpers = class {
+  constructor(client) {
+    this.initialized = false;
+    this.client = client;
+    this.clerk = new ClerkManager((token) => {
+      if (token) {
+        this.client.setUserToken(token);
+      } else {
+        this.client.clearUserToken();
+      }
+    });
+  }
+  /**
+   * Initialize auth (loads Clerk internally).
+   * Call this on page load to detect existing sessions.
+   *
+   * @example
+   * ```typescript
+   * await api.auth.init();
+   * if (api.auth.isSignedIn()) {
+   *   // User is signed in, token already set
+   *   await api.usage.track();
+   * }
+   * ```
+   */
+  async init() {
+    if (this.initialized) return;
+    await this.clerk.load();
+    this.initialized = true;
+  }
+  /**
+   * Check if user is signed in
+   */
+  isSignedIn() {
+    return this.clerk.isSignedIn();
+  }
+  /**
+   * Get current user info
+   */
+  getUser() {
+    return this.clerk.getUser();
+  }
+  /**
+   * Sign out the current user
+   */
+  async signOut() {
+    await this.clerk.signOut();
+  }
+  /**
+   * Refresh the auth token (call before long sessions)
+   */
+  async refreshToken() {
+    await this.clerk.refreshToken();
+  }
+  /**
+   * Check if returning from auth redirect
+   */
+  static hasAuthParams() {
+    return ClerkManager.hasAuthParams();
+  }
+  /**
+   * Get the sign-up URL for new users.
+   *
+   * Redirects to the sign-up worker which handles user creation
+   * and sets the required metadata (publishableKey, plan).
+   *
+   * @example
+   * ```typescript
+   * const signupUrl = api.auth.getSignUpUrl({ redirect: '/dashboard' });
+   * // Returns: https://sign-up.../signup?pk=pk_xxx&redirect=...
+   * window.location.href = signupUrl;
+   * ```
+   */
+  getSignUpUrl(options) {
+    const pk = this.client.getPublishableKey();
+    if (!pk) {
+      throw new Error("DreamAPI: publishableKey required for auth URLs");
+    }
+    const baseUrl = this.client.getSignupBaseUrl();
+    const params = new URLSearchParams({
+      pk,
+      redirect: options.redirect
+    });
+    return `${baseUrl}/signup?${params.toString()}`;
+  }
+  /**
+   * Get the sign-in URL for returning users.
+   *
+   * Redirects to Clerk's hosted sign-in page. After sign-in,
+   * users are redirected to your specified URL.
+   *
+   * @example
+   * ```typescript
+   * const signinUrl = api.auth.getSignInUrl({ redirect: '/dashboard' });
+   * window.location.href = signinUrl;
+   * ```
+   */
+  getSignInUrl(options) {
+    const clerkBaseUrl = this.client.getClerkBaseUrl();
+    return `${clerkBaseUrl}/sign-in?redirect_url=${encodeURIComponent(options.redirect)}`;
+  }
+  /**
+   * Get the customer portal URL for account management.
+   *
+   * Redirects to Clerk's hosted account page where users can
+   * manage their profile, password, and security settings.
+   *
+   * Note: This is separate from billing management.
+   * For billing, use api.billing.openPortal().
+   *
+   * @example
+   * ```typescript
+   * const portalUrl = api.auth.getCustomerPortalUrl();
+   * window.location.href = portalUrl;
+   * ```
+   */
+  getCustomerPortalUrl() {
+    const clerkBaseUrl = this.client.getClerkBaseUrl();
+    return `${clerkBaseUrl}/user`;
+  }
+};
+
+// src/index.ts
+var DreamAPI = class {
+  constructor(config) {
+    this.client = new DreamClient(config);
+    this.auth = new AuthHelpers(this.client);
+    this.customers = new CustomerAPI(this.client);
+    this.usage = new UsageAPI(this.client);
+    this.billing = new BillingAPI(this.client);
+    this.products = new ProductAPI(this.client);
+    this.dashboard = new DashboardAPI(this.client);
+  }
+  /**
+   * Set the end-user JWT token.
+   * Required for user-specific operations (usage, billing).
+   *
+   * @example
+   * ```typescript
+   * // After user signs in via Clerk
+   * const token = await clerk.session.getToken();
+   * api.setUserToken(token);
+   * ```
+   */
+  setUserToken(token) {
+    this.client.setUserToken(token);
+  }
+  /**
+   * Clear the user token (on sign out)
+   */
+  clearUserToken() {
+    this.client.clearUserToken();
+  }
+};
+var CustomerAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new customer
+   *
+   * @example
+   * ```typescript
+   * const { customer } = await api.customers.create({
+   *   email: 'user@example.com',
+   *   firstName: 'John',
+   *   plan: 'free',
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.client.post("/api/customers", params);
+  }
+  /**
+   * Get a customer by ID
+   */
+  async get(customerId) {
+    return this.client.get(`/api/customers/${customerId}`);
+  }
+  /**
+   * Update a customer's plan
+   */
+  async update(customerId, params) {
+    return this.client.patch(`/api/customers/${customerId}`, params);
+  }
+  /**
+   * Delete a customer
+   */
+  async delete(customerId) {
+    return this.client.delete(`/api/customers/${customerId}`);
+  }
+};
+var UsageAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Track a usage event.
+   * Increments the user's usage counter for the current period.
+   *
+   * @example
+   * ```typescript
+   * const { usage } = await api.usage.track();
+   * console.log(`Used ${usage.usageCount} of ${usage.limit}`);
+   * ```
+   */
+  async track() {
+    const response = await this.client.post("/api/data", null, true);
+    if ("success" in response) {
+      return response;
+    }
+    return { success: true, usage: response };
+  }
+  /**
+   * Check current usage without incrementing.
+   *
+   * @example
+   * ```typescript
+   * const usage = await api.usage.check();
+   * if (usage.remaining <= 0) {
+   *   // Show upgrade prompt
+   * }
+   * ```
+   */
+  async check() {
+    const response = await this.client.get("/api/usage", true);
+    return response.usage || response;
+  }
+};
+var BillingAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a checkout session for subscription upgrade.
+   *
+   * @example
+   * ```typescript
+   * const { url } = await api.billing.createCheckout({
+   *   tier: 'pro',
+   *   successUrl: '/success',
+   *   cancelUrl: '/pricing',
+   * });
+   * window.location.href = url;
+   * ```
+   */
+  async createCheckout(params) {
+    return this.client.post("/api/create-checkout", params, true);
+  }
+  /**
+   * Open the Stripe customer portal for billing management.
+   *
+   * @example
+   * ```typescript
+   * const { url } = await api.billing.openPortal({ returnUrl: '/dashboard' });
+   * window.location.href = url;
+   * ```
+   */
+  async openPortal(params) {
+    return this.client.post("/api/customer-portal", params, true);
+  }
+};
+var ProductAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List subscription tiers
+   */
+  async listTiers() {
+    return this.client.get("/api/tiers");
+  }
+  /**
+   * List products (for store projects)
+   */
+  async list() {
+    return this.client.get("/api/products");
+  }
+  /**
+   * Create a cart checkout (guest checkout for store)
+   */
+  async cartCheckout(params) {
+    return this.client.post("/api/cart/checkout", params);
+  }
+};
+var DashboardAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get dashboard metrics
+   *
+   * @example
+   * ```typescript
+   * const dashboard = await api.dashboard.get();
+   * console.log(`MRR: $${dashboard.mrr}`);
+   * console.log(`Active subs: ${dashboard.activeSubscriptions}`);
+   * ```
+   */
+  async get() {
+    return this.client.get("/api/dashboard");
+  }
+  /**
+   * Get aggregate totals across all projects
+   */
+  async getTotals() {
+    return this.client.get("/api/dashboard/totals");
+  }
+};
+var index_default = DreamAPI;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DreamAPI,
+  DreamAPIException
+});