@memberstack/dom 2.0.1 → 2.0.2

package/lib/testing/index.d.ts

@@ -0,0 +1,295 @@
+import { M as Member, a as Plan, c as PlanConnection, g as MemberCard, b as Price, A as App, C as ContentGroup } from '../models-CFT_ABd5.js';
+
+/**
+ * @fileoverview Test utilities for Memberstack SDK.
+ * Provides mock factories and helpers for testing applications that use Memberstack.
+ *
+ * @example
+ * ```typescript
+ * import { createMockMemberstack, mockMember, mockPlan } from '@memberstack/dom/testing';
+ *
+ * // Create a mock SDK instance
+ * const mockMs = createMockMemberstack({
+ *   member: mockMember({ email: 'test@example.com' }),
+ *   plans: [mockPlan({ name: 'Pro' })]
+ * });
+ *
+ * // Use in tests
+ * const { data: member } = await mockMs.getCurrentMember();
+ * expect(member?.auth.email).toBe('test@example.com');
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Creates a mock member object with sensible defaults.
+ * Override any property by passing it in the options.
+ *
+ * @param overrides - Partial member data to override defaults
+ * @returns A complete mock Member object
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const member = mockMember();
+ *
+ * // With custom email
+ * const member = mockMember({ auth: { email: 'custom@test.com' } });
+ *
+ * // With plans
+ * const member = mockMember({
+ *   planConnections: [mockPlanConnection({ planId: 'pln_abc123' })]
+ * });
+ * ```
+ */
+declare function mockMember(overrides?: DeepPartial<Member>): Member;
+/**
+ * Creates a mock plan object.
+ *
+ * @param overrides - Partial plan data to override defaults
+ * @returns A complete mock Plan object
+ *
+ * @example
+ * ```typescript
+ * const freePlan = mockPlan({ name: 'Free', prices: [] });
+ * const proPlan = mockPlan({
+ *   name: 'Pro',
+ *   prices: [mockPrice({ amount: '9.99' })]
+ * });
+ * ```
+ */
+declare function mockPlan(overrides?: DeepPartial<Plan>): Plan;
+/**
+ * Creates a mock plan connection (member's subscription to a plan).
+ *
+ * @param overrides - Partial connection data to override defaults
+ * @returns A complete mock PlanConnection object
+ *
+ * @example
+ * ```typescript
+ * // Active subscription
+ * const conn = mockPlanConnection({ active: true, status: 'ACTIVE' });
+ *
+ * // Canceled subscription
+ * const conn = mockPlanConnection({
+ *   active: false,
+ *   status: 'CANCELED',
+ *   payment: { cancelAtDate: Date.now() + 86400000 }
+ * });
+ * ```
+ */
+declare function mockPlanConnection(overrides?: DeepPartial<PlanConnection>): PlanConnection;
+/**
+ * Creates a mock payment card.
+ *
+ * @param overrides - Partial card data to override defaults
+ * @returns A complete mock MemberCard object
+ */
+declare function mockCard(overrides?: DeepPartial<MemberCard>): MemberCard;
+/**
+ * Creates a mock price object for a plan.
+ *
+ * @param overrides - Partial price data to override defaults
+ * @returns A complete mock Price object
+ *
+ * @example
+ * ```typescript
+ * const monthlyPrice = mockPrice({ amount: '9.99', name: 'Monthly' });
+ * const yearlyPrice = mockPrice({
+ *   amount: '99.99',
+ *   name: 'Yearly',
+ *   interval: { type: 'year', count: 1 }
+ * });
+ * ```
+ */
+declare function mockPrice(overrides?: DeepPartial<Price>): Price;
+/**
+ * Creates a mock app configuration.
+ *
+ * @param overrides - Partial app data to override defaults
+ * @returns A complete mock App object
+ */
+declare function mockApp(overrides?: DeepPartial<App>): App;
+/**
+ * Creates a mock content group (restricted URL group).
+ *
+ * @param overrides - Partial group data to override defaults
+ * @returns A complete mock ContentGroup object
+ */
+declare function mockContentGroup(overrides?: DeepPartial<ContentGroup>): ContentGroup;
+/**
+ * Options for creating a mock Memberstack instance.
+ */
+interface MockMemberstackOptions {
+    /** The currently logged-in member, or null if logged out */
+    member?: Member | null;
+    /** Available plans in the app */
+    plans?: Plan[];
+    /** App configuration */
+    app?: App;
+    /** Content groups */
+    contentGroups?: ContentGroup[];
+    /** Member's saved cards */
+    cards?: MemberCard[];
+    /** Custom method overrides */
+    overrides?: Partial<MockMemberstackInstance>;
+}
+/**
+ * Mock implementation of the Memberstack SDK.
+ * Implements the most commonly used methods for testing.
+ */
+interface MockMemberstackInstance {
+    getCurrentMember: () => Promise<{
+        data: Member | null;
+    }>;
+    getPlans: () => Promise<{
+        data: Plan[];
+    }>;
+    getPlan: (params: {
+        planId: string;
+    }) => Promise<{
+        data: Plan | null;
+    }>;
+    getApp: () => Promise<{
+        data: App;
+    }>;
+    getRestrictedUrlGroups: () => Promise<{
+        data: ContentGroup[];
+    }>;
+    getMemberCards: () => Promise<{
+        data: MemberCard[];
+    }>;
+    loginMemberEmailPassword: (params: {
+        email: string;
+        password: string;
+    }) => Promise<{
+        data: {
+            member: Member;
+            tokens: {
+                accessToken: string;
+                expires: number;
+                type: string;
+            };
+            redirect: string;
+        };
+    }>;
+    signupMemberEmailPassword: (params: {
+        email: string;
+        password: string;
+    }) => Promise<{
+        data: {
+            member: Member;
+            tokens: {
+                accessToken: string;
+                expires: number;
+                type: string;
+            };
+            redirect: string;
+        };
+    }>;
+    logout: () => Promise<{
+        data: {
+            redirect?: string;
+        };
+    }>;
+    updateMember: (params: {
+        customFields?: object;
+    }) => Promise<{
+        data: Member;
+    }>;
+    onAuthChange: (callback: (payload: {
+        member: Member | null;
+    }) => void) => () => void;
+    _setMember: (member: Member | null) => void;
+    _getMockState: () => {
+        member: Member | null;
+        plans: Plan[];
+        app: App;
+    };
+}
+/**
+ * Creates a mock Memberstack SDK instance for testing.
+ * All methods return promises with mock data based on the provided options.
+ *
+ * @param options - Configuration for the mock instance
+ * @returns A mock Memberstack instance with common methods
+ *
+ * @example
+ * ```typescript
+ * // Basic setup
+ * const mockMs = createMockMemberstack({
+ *   member: mockMember({ auth: { email: 'test@test.com' } }),
+ *   plans: [mockPlan({ name: 'Free' }), mockPlan({ name: 'Pro' })]
+ * });
+ *
+ * // Use in component tests
+ * const { data: member } = await mockMs.getCurrentMember();
+ * expect(member).not.toBeNull();
+ *
+ * // Test logout flow
+ * await mockMs.logout();
+ * const { data: afterLogout } = await mockMs.getCurrentMember();
+ * expect(afterLogout).toBeNull();
+ *
+ * // Subscribe to auth changes
+ * const authCallback = jest.fn();
+ * mockMs.onAuthChange(authCallback);
+ * mockMs._setMember(null); // Simulate logout
+ * expect(authCallback).toHaveBeenCalledWith({ member: null });
+ * ```
+ */
+declare function createMockMemberstack(options?: MockMemberstackOptions): MockMemberstackInstance;
+/** Deep partial type for nested object overrides */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Custom matchers for testing Memberstack data.
+ * These can be extended with Jest's expect.extend() or Vitest's expect.extend().
+ *
+ * @example
+ * ```typescript
+ * // In your test setup file:
+ * import { memberstackMatchers } from '@memberstack/dom/testing';
+ * expect.extend(memberstackMatchers);
+ *
+ * // In tests:
+ * expect(member).toBeLoggedIn();
+ * expect(member).toHavePlan('pln_abc123');
+ * ```
+ */
+declare const memberstackMatchers: {
+    /**
+     * Assert that a member is logged in (not null and has an email).
+     */
+    toBeLoggedIn(received: Member | null): {
+        pass: boolean;
+        message: () => string;
+    };
+    /**
+     * Assert that a member has a specific plan.
+     */
+    toHavePlan(received: Member | null, planId: string): {
+        pass: boolean;
+        message: () => string;
+    };
+    /**
+     * Assert that a member's email is verified.
+     */
+    toBeVerified(received: Member | null): {
+        pass: boolean;
+        message: () => "Expected member not to be verified" | "Expected member to be verified";
+    };
+};
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeLoggedIn(): R;
+            toHavePlan(planId: string): R;
+            toBeVerified(): R;
+        }
+    }
+}
+
+export { type MockMemberstackInstance, type MockMemberstackOptions, createMockMemberstack, memberstackMatchers, mockApp, mockCard, mockContentGroup, mockMember, mockPlan, mockPlanConnection, mockPrice };

package/lib/testing/index.js

@@ -0,0 +1,335 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/testing/index.ts
+var testing_exports = {};
+__export(testing_exports, {
+  createMockMemberstack: () => createMockMemberstack,
+  memberstackMatchers: () => memberstackMatchers,
+  mockApp: () => mockApp,
+  mockCard: () => mockCard,
+  mockContentGroup: () => mockContentGroup,
+  mockMember: () => mockMember,
+  mockPlan: () => mockPlan,
+  mockPlanConnection: () => mockPlanConnection,
+  mockPrice: () => mockPrice
+});
+module.exports = __toCommonJS(testing_exports);
+function mockMember(overrides = {}) {
+  const defaults = {
+    id: `mem_${randomId()}`,
+    verified: true,
+    profileImage: "",
+    auth: {
+      email: "test@example.com",
+      hasPassword: true,
+      providers: []
+    },
+    loginRedirect: "/",
+    stripeCustomerId: "",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metaData: {},
+    customFields: {},
+    permissions: [],
+    planConnections: []
+  };
+  return deepMerge(defaults, overrides);
+}
+function mockPlan(overrides = {}) {
+  const defaults = {
+    id: `pln_${randomId()}`,
+    name: "Test Plan",
+    description: "A test plan",
+    status: "PUBLISHED",
+    redirects: {
+      afterLogin: "/",
+      afterLogout: "/",
+      afterSignup: "/"
+    },
+    prices: []
+  };
+  return deepMerge(defaults, overrides);
+}
+function mockPlanConnection(overrides = {}) {
+  const defaults = {
+    id: `conn_${randomId()}`,
+    active: true,
+    status: "ACTIVE",
+    planId: `pln_${randomId()}`,
+    type: "FREE",
+    payment: null
+  };
+  return deepMerge(defaults, overrides);
+}
+function mockCard(overrides = {}) {
+  const defaults = {
+    id: `card_${randomId()}`,
+    brand: "visa",
+    expMonth: "12",
+    expYear: String((/* @__PURE__ */ new Date()).getFullYear() + 3),
+    last4: "4242",
+    default: true
+  };
+  return deepMerge(defaults, overrides);
+}
+function mockPrice(overrides = {}) {
+  const defaults = {
+    id: `prc_${randomId()}`,
+    amount: "0",
+    interval: {
+      type: "month",
+      count: 1
+    },
+    name: "Monthly",
+    type: "SUBSCRIPTION",
+    status: "ACTIVE",
+    currency: "usd"
+  };
+  return deepMerge(defaults, overrides);
+}
+function mockApp(overrides = {}) {
+  const defaults = {
+    id: `app_${randomId()}`,
+    name: "Test App",
+    mode: "sandbox",
+    plans: [],
+    contentGroups: [],
+    emailVerificationEnabled: false,
+    requireEmailVerification: false,
+    customField: [],
+    branding: {
+      logo: "",
+      colors: {
+        lightMode: {
+          primaryButton: "#6366f1"
+        }
+      }
+    },
+    authProviders: []
+  };
+  return deepMerge(defaults, overrides);
+}
+function mockContentGroup(overrides = {}) {
+  const defaults = {
+    id: `grp_${randomId()}`,
+    name: "Test Group",
+    key: "test-group",
+    allowAllMembers: false,
+    activeMemberHasAccess: false,
+    redirect: "/login",
+    urls: [],
+    plans: []
+  };
+  return deepMerge(defaults, overrides);
+}
+function createMockMemberstack(options = {}) {
+  var _a, _b, _c, _d, _e;
+  let currentMember = (_a = options.member) != null ? _a : null;
+  const plans = (_b = options.plans) != null ? _b : [];
+  const app = (_c = options.app) != null ? _c : mockApp();
+  const contentGroups = (_d = options.contentGroups) != null ? _d : [];
+  const cards = (_e = options.cards) != null ? _e : [];
+  const authListeners = [];
+  const notifyAuthChange = () => {
+    authListeners.forEach((cb) => cb({ member: currentMember }));
+  };
+  const instance = {
+    getCurrentMember: () => __async(this, null, function* () {
+      return { data: currentMember };
+    }),
+    getPlans: () => __async(this, null, function* () {
+      return { data: plans };
+    }),
+    getPlan: (_0) => __async(this, [_0], function* ({ planId }) {
+      var _a2;
+      return {
+        data: (_a2 = plans.find((p) => p.id === planId)) != null ? _a2 : null
+      };
+    }),
+    getApp: () => __async(this, null, function* () {
+      return { data: app };
+    }),
+    getRestrictedUrlGroups: () => __async(this, null, function* () {
+      return { data: contentGroups };
+    }),
+    getMemberCards: () => __async(this, null, function* () {
+      return { data: cards };
+    }),
+    loginMemberEmailPassword: (_0) => __async(this, [_0], function* ({ email }) {
+      currentMember = mockMember({ auth: { email, hasPassword: true, providers: [] } });
+      notifyAuthChange();
+      return {
+        data: {
+          member: currentMember,
+          tokens: { accessToken: `mock_token_${randomId()}`, expires: Date.now() + 36e5, type: "bearer" },
+          redirect: "/"
+        }
+      };
+    }),
+    signupMemberEmailPassword: (_0) => __async(this, [_0], function* ({ email }) {
+      currentMember = mockMember({ auth: { email, hasPassword: true, providers: [] } });
+      notifyAuthChange();
+      return {
+        data: {
+          member: currentMember,
+          tokens: { accessToken: `mock_token_${randomId()}`, expires: Date.now() + 36e5, type: "bearer" },
+          redirect: "/"
+        }
+      };
+    }),
+    logout: () => __async(this, null, function* () {
+      currentMember = null;
+      notifyAuthChange();
+      return { data: {} };
+    }),
+    updateMember: (_0) => __async(this, [_0], function* ({ customFields }) {
+      if (!currentMember) {
+        throw new Error("Not logged in");
+      }
+      if (customFields) {
+        currentMember = __spreadProps(__spreadValues({}, currentMember), {
+          customFields: __spreadValues(__spreadValues({}, currentMember.customFields), customFields)
+        });
+      }
+      return { data: currentMember };
+    }),
+    onAuthChange: (callback) => {
+      authListeners.push(callback);
+      callback({ member: currentMember });
+      return () => {
+        const index = authListeners.indexOf(callback);
+        if (index > -1)
+          authListeners.splice(index, 1);
+      };
+    },
+    // Test helpers
+    _setMember: (member) => {
+      currentMember = member;
+      notifyAuthChange();
+    },
+    _getMockState: () => ({ member: currentMember, plans, app })
+  };
+  if (options.overrides) {
+    Object.assign(instance, options.overrides);
+  }
+  return instance;
+}
+function randomId() {
+  return Math.random().toString(36).substring(2, 10);
+}
+function deepMerge(target, source) {
+  const result = __spreadValues({}, target);
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+var memberstackMatchers = {
+  /**
+   * Assert that a member is logged in (not null and has an email).
+   */
+  toBeLoggedIn(received) {
+    var _a;
+    const pass = received !== null && typeof ((_a = received.auth) == null ? void 0 : _a.email) === "string";
+    return {
+      pass,
+      message: () => pass ? `Expected member not to be logged in` : `Expected member to be logged in, but got ${received === null ? "null" : "invalid member object"}`
+    };
+  },
+  /**
+   * Assert that a member has a specific plan.
+   */
+  toHavePlan(received, planId) {
+    var _a, _b;
+    const hasPlan = (_b = (_a = received == null ? void 0 : received.planConnections) == null ? void 0 : _a.some(
+      (conn) => conn.planId === planId && conn.active
+    )) != null ? _b : false;
+    return {
+      pass: hasPlan,
+      message: () => hasPlan ? `Expected member not to have plan ${planId}` : `Expected member to have plan ${planId}, but they don't`
+    };
+  },
+  /**
+   * Assert that a member's email is verified.
+   */
+  toBeVerified(received) {
+    const pass = (received == null ? void 0 : received.verified) === true;
+    return {
+      pass,
+      message: () => pass ? `Expected member not to be verified` : `Expected member to be verified`
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMockMemberstack,
+  memberstackMatchers,
+  mockApp,
+  mockCard,
+  mockContentGroup,
+  mockMember,
+  mockPlan,
+  mockPlanConnection,
+  mockPrice
+});