@lacagnottedesproches/lcdp-js-lite 1.6.0

package/README.md

@@ -0,0 +1,9 @@
+[![Test with coverage afina-js-lite 🎉](https://github.com/lacagnottedesproches/afina-js-lite/actions/workflows/test.js.yml/badge.svg)](https://github.com/lacagnottedesproches/afina-js-lite/actions/workflows/test.js.yml)
+
+[![Build and test with coverage afina-js-lite 🎉](https://github.com/lacagnottedesproches/afina-js-lite/actions/workflows/node.js.yml/badge.svg)](https://github.com/lacagnottedesproches/afina-js-lite/actions/workflows/node.js.yml)
+
+<div align="center">
+  <h1>La Cagnotte des Proches - Afina JS Lite</h1>
+</div>
+
+The SDK JS, that is a wrapper around **afina-sdk**.

package/__tests__/api.test.ts

@@ -0,0 +1,171 @@
+import fetchMock from "jest-fetch-mock";
+
+import { LCDPRequest } from "../src/api";
+import { TokenObject } from "../src/types";
+
+const API_URL = "https://api.test.local";
+const SECRET = "sk_test_123";
+
+const mockToken: TokenObject = {
+  id: "tok_123",
+  type: "account" as any,
+  client_ip: "127.0.0.1",
+};
+
+describe("LCDPRequest (with jest-fetch-mock)", () => {
+  beforeEach(() => {
+    fetchMock.resetMocks();
+  });
+
+  test("constructor throws if window is defined", () => {
+    (global as any).window = {};
+
+    expect(() => new LCDPRequest(SECRET, API_URL)).toThrow(
+      "Must be used server side",
+    );
+
+    delete (global as any).window;
+  });
+
+  test("requestLCDPApi throws if window is defined", async () => {
+    const api = new LCDPRequest(SECRET, API_URL);
+
+    (global as any).window = {};
+
+    expect(() => api.requestLCDPApi("accounts", mockToken, SECRET)).toThrow(
+      "Must be used server side",
+    );
+
+    delete (global as any).window;
+  });
+
+  test("requestLCDPApi - success JSON", async () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
+
+    const api = new LCDPRequest(SECRET, API_URL);
+
+    const res = await api.requestLCDPApi("accounts", mockToken, SECRET);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${API_URL}/accounts`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          Authorization: `Bearer ${SECRET}`,
+        }),
+      }),
+    );
+
+    expect(res).toEqual({ ok: true });
+  });
+
+  test("requestLCDPApi - 204 No Content", async () => {
+    fetchMock.mockResponseOnce("", { status: 204 });
+
+    const api = new LCDPRequest(SECRET, API_URL);
+
+    const res = await api.requestLCDPApi("accounts", mockToken, SECRET);
+
+    expect(res).toBeUndefined();
+  });
+
+  test("requestLCDPApi - rejects on 400", async () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ detail: "Bad Request" }), {
+      status: 400,
+    });
+
+    const api = new LCDPRequest(SECRET, API_URL);
+
+    await expect(
+      api.requestLCDPApi("accounts", mockToken, SECRET),
+    ).rejects.toBe("Bad Request");
+  });
+
+  test("requestLCDPApi - rejects on 500", async () => {
+    fetchMock.mockResponseOnce(
+      JSON.stringify({ detail: "Internal server error" }),
+      {
+        status: 500,
+      },
+    );
+
+    const api = new LCDPRequest(SECRET, API_URL);
+
+    await expect(
+      api.requestLCDPApi("accounts", mockToken, SECRET),
+    ).rejects.toBe("Internal server error");
+  });
+
+  test("createAccount()", async () => {
+    fetchMock.mockResponseOnce(
+      JSON.stringify({
+        acct_id: "acc_1",
+        first_name: "John",
+        last_name: "Doe",
+        email: "john@test.com",
+      }),
+      { status: 200 },
+    );
+
+    const api = new LCDPRequest(SECRET, API_URL);
+    const res = await api.createAccount(mockToken);
+
+    expect(res.acct_id).toBe("acc_1");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("createPot()", async () => {
+    fetchMock.mockResponseOnce(
+      JSON.stringify({
+        pot_id: "pot_1",
+        name: "My pot",
+        slug: "my-pot",
+      }),
+      { status: 200 },
+    );
+
+    const api = new LCDPRequest(SECRET, API_URL);
+    const res = await api.createPot(mockToken);
+
+    expect(res.pot_id).toBe("pot_1");
+  });
+
+  test("createAccountAndPot()", async () => {
+    fetchMock.mockResponseOnce(
+      JSON.stringify({
+        account: {
+          acct_id: "acc_1",
+          first_name: "John",
+          last_name: "Doe",
+          email: "john@test.com",
+        },
+        pot: {
+          pot_id: "pot_1",
+          name: "My pot",
+          slug: "my-pot",
+        },
+      }),
+      { status: 200 },
+    );
+
+    const api = new LCDPRequest(SECRET, API_URL);
+    const res = await api.createAccountAndPot(mockToken);
+
+    expect(res.account.acct_id).toBe("acc_1");
+    expect(res.pot.pot_id).toBe("pot_1");
+  });
+
+  test("updatePot() uses PATCH and resolves void", async () => {
+    fetchMock.mockResponseOnce("", { status: 204 });
+
+    const api = new LCDPRequest(SECRET, API_URL);
+    await api.updatePot(mockToken);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${API_URL}/pots`,
+      expect.objectContaining({
+        method: "PATCH",
+      }),
+    );
+  });
+});

package/__tests__/index.test.ts

@@ -0,0 +1,228 @@
+import { loadLCDP, requestLCDP } from "../src";
+import { LCDPRequest } from "../src/api";
+
+describe("index.ts in node env", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Reset window between tests
+    (globalThis as any).window = {};
+    (globalThis as any).window.lcdp = undefined;
+  });
+
+  it("resolves null if window is missing", async () => {
+    const originalWindow = (globalThis as any).window;
+    const originalDocument = (globalThis as any).document;
+
+    delete (globalThis as any).window;
+    delete (globalThis as any).document;
+
+    const result = await loadLCDP("key");
+
+    expect(result).toBeNull();
+
+    // Restore
+    (globalThis as any).window = originalWindow;
+    (globalThis as any).document = originalDocument;
+  });
+
+  it("uses existing window.lcdp.Afina", async () => {
+    jest.resetModules();
+
+    const initMock = jest.fn().mockResolvedValue({ ready: true });
+
+    (globalThis as any).window.lcdp = {
+      Afina: function (...args: any[]) {
+        (this as any).init = initMock;
+      },
+    };
+
+    const { loadLCDP } = await import("../src");
+    const result = await loadLCDP("key");
+
+    expect(initMock).toHaveBeenCalled();
+    expect(result).toEqual({ ready: true });
+  });
+
+  it("injects script if not present", async () => {
+    jest.resetModules(); // reset module-level state
+
+    const initMock = jest.fn().mockResolvedValue({ ok: true });
+
+    // recreate window before importing
+    (globalThis as any).window = {};
+    (globalThis as any).document = {
+      head: { appendChild: jest.fn() },
+      body: { appendChild: jest.fn() },
+      createElement: jest.fn((tag: string) => {
+        if (tag === "script") {
+          return {
+            src: "",
+            addEventListener: jest.fn((event, cb) => {
+              // automatically call 'load' after a tick
+              if (event === "load") {
+                setTimeout(() => {
+                  // mock window.lcdp only when load triggers
+                  (globalThis as any).window = {};
+                  (globalThis as any).window.lcdp = {
+                    Afina: function () {
+                      this.init = initMock;
+                    },
+                  };
+                  cb();
+                }, 0);
+              }
+            }),
+            removeEventListener: jest.fn(),
+            parentNode: { removeChild: jest.fn() },
+          };
+        }
+        return { appendChild: jest.fn(), id: "" };
+      }),
+      querySelectorAll: jest.fn(() => []),
+    };
+
+    // import fresh module after window/document mocks
+    const { loadLCDP } = await import("../src");
+
+    const result = await loadLCDP("key");
+
+    expect(initMock).toHaveBeenCalled();
+    expect(result).toEqual({ ok: true });
+  });
+
+  it("does not injects script if already present", async () => {
+    jest.resetModules(); // reset module-level state
+
+    const initMock = jest.fn().mockResolvedValue({ ok: true });
+
+    // recreate window before importing
+    (globalThis as any).window = {};
+    (globalThis as any).document = {
+      head: { appendChild: jest.fn() },
+      body: { appendChild: jest.fn() },
+      createElement: jest.fn((tag: string) => {
+        if (tag === "script") {
+          return {
+            src: "",
+            addEventListener: jest.fn((event, cb) => {
+              // automatically call 'load' after a tick
+              if (event === "load") {
+                setTimeout(() => {
+                  // mock window.lcdp only when load triggers
+                  (globalThis as any).window = {};
+                  (globalThis as any).window.lcdp = {
+                    Afina: function () {
+                      this.init = initMock;
+                    },
+                  };
+                  cb();
+                }, 0);
+              }
+            }),
+            removeEventListener: jest.fn(),
+            parentNode: { removeChild: jest.fn() },
+          };
+        }
+        return { appendChild: jest.fn(), id: "" };
+      }),
+      querySelectorAll: jest.fn(() => [
+        {
+          src: "",
+          addEventListener: jest.fn((event, cb) => {
+            // automatically call 'load' after a tick
+            if (event === "load") {
+              setTimeout(() => {
+                // mock window.lcdp only when load triggers
+                (globalThis as any).window = {};
+                (globalThis as any).window.lcdp = {
+                  Afina: function () {
+                    this.init = initMock;
+                  },
+                };
+                cb();
+              }, 0);
+            }
+          }),
+          removeEventListener: jest.fn(),
+          parentNode: { removeChild: jest.fn() },
+        },
+      ]),
+    };
+
+    // import fresh module after window/document mocks
+    const { loadLCDP } = await import("../src");
+
+    const result = await loadLCDP("key");
+
+    expect(initMock).toHaveBeenCalled();
+    expect(result).toEqual({ ok: true });
+  });
+
+  it("rejects when script fails to load", async () => {
+    jest.resetModules(); // reset module-level state
+
+    const initMock = jest.fn().mockResolvedValue({ ok: true });
+
+    // recreate window before importing
+    (globalThis as any).window = {};
+    (globalThis as any).document = {
+      head: { appendChild: jest.fn() },
+      body: { appendChild: jest.fn() },
+      createElement: jest.fn((tag: string) => {
+        if (tag === "script") {
+          return {
+            src: "",
+            addEventListener: jest.fn((event, cb) => {
+              // automatically call 'load' after a tick
+              if (event === "load") {
+                setTimeout(() => {
+                  // mock window.lcdp only when load triggers
+                  (globalThis as any).window = {};
+                  (globalThis as any).window.lcdp = {
+                    Afina: function () {
+                      this.init = initMock;
+                    },
+                  };
+                  cb();
+                }, 0);
+              }
+            }),
+            removeEventListener: jest.fn(),
+            parentNode: { removeChild: jest.fn() },
+          };
+        }
+        return { appendChild: jest.fn(), id: "" };
+      }),
+      querySelectorAll: jest.fn(() => []),
+    };
+
+    // import fresh module after window/document mocks
+    const { loadLCDP } = await import("../src");
+
+    const promise = loadLCDP("key");
+
+    const mockScript = (document.createElement as jest.Mock).mock.results[0]
+      .value;
+
+    const errorHandler = mockScript.addEventListener.mock.calls.find(
+      (c: any) => c[0] === "error",
+    )[1];
+
+    errorHandler();
+
+    await expect(promise).rejects.toThrow("Failed to load lcdp.js");
+  });
+
+  it("requestLCDP returns LCDPRequest", () => {
+    jest.clearAllMocks();
+
+    // Reset window between tests
+    (globalThis as any).window = undefined;
+
+    const client = requestLCDP("secret");
+
+    expect(client).toBeInstanceOf(LCDPRequest);
+    expect(client._apiToken).toBe("secret");
+  });
+});

package/__tests__/types.runtime.test.ts

@@ -0,0 +1,16 @@
+import { AfinaError, TokenObjectType } from "../src/types";
+
+describe("Runtime enums", () => {
+  test("AfinaError values", () => {
+    expect(AfinaError.Verify).toBe("Fail to verify origin request");
+    expect(AfinaError.Stripe).toBe("Stripe is not available");
+    expect(AfinaError.ClientSide).toBe("Should be on Client Side");
+    expect(AfinaError.Key).toBe("A publishable key is mandatory");
+  });
+
+  test("TokenObjectType values", () => {
+    expect(TokenObjectType.Account).toBe("account");
+    expect(TokenObjectType.Pot).toBe("pot");
+    expect(TokenObjectType.Wizard).toBe("wizard");
+  });
+});

package/__tests__/types.test-d.ts

@@ -0,0 +1,87 @@
+import { expectType } from "tsd";
+import {
+  Pot,
+  PayloadAccount,
+  DonationResult,
+  TokenObject,
+  ParamsPagination,
+  LCDP,
+  TokenObjectType,
+} from "../src/types";
+
+// ---- Pot ----
+expectType<Pot>({
+  id: "123",
+  date_created_ts: 1234567890,
+  slug: "slug",
+  name: "Pot name",
+  date_end_ts: null,
+  objectif: null,
+  status_online: true,
+  status_public: true,
+  status_closed: false,
+  amount_collected_hidden: false,
+  public_pot_url: "url",
+  public_donation_url: "url",
+  stat_amount_donation: null,
+  stat_nb_donation: 0,
+  profit_acct: null,
+  profit_ghost: null,
+  description: null,
+  video: null,
+  visual_main_url: null,
+  visual_secondary_url: null,
+  with_tax_receipt: false,
+});
+
+// ---- PayloadAccount ----
+expectType<PayloadAccount>({
+  email: "test@test.com",
+  first_name: "John",
+  last_name: "Doe",
+  birth_date: new Date(),
+  address: "Street",
+  postcode: "75000",
+  city: "Paris",
+  phone_number: "0600000000",
+  country_code: "FR",
+});
+
+// ---- DonationResult ----
+expectType<DonationResult>({
+  status: "requires_action",
+  client_secret: "sec_123",
+});
+
+// ---- TokenObject ----
+expectType<TokenObject>({
+  id: "tok_123",
+  type: TokenObjectType.Account,
+  client_ip: "127.0.0.1",
+});
+
+// ---- ParamsPagination ----
+expectType<ParamsPagination>({
+  page: 1,
+  per_page: 10,
+});
+
+// ---- LCDP shape ----
+expectType<LCDP>({
+  stripe: null,
+  init: async () => ({}) as any,
+  createTokenAccount: async () => ({}) as any,
+  createTokenPot: async () => ({}) as any,
+  createTokenAccountAndPot: async () => ({}) as any,
+  createTokenPotUpdate: async () => ({}) as any,
+  createDonation: async () => ({}) as any,
+  getAvailableCountries: async () => [],
+  getCategories: async () => [],
+  getPots: async () => ({}) as any,
+  getPot: async () => ({}) as any,
+  getStatsDashboard: async () => ({}) as any,
+  getStatsPots: async () => ({}) as any,
+  retrieveAssociations: async () => ({}) as any,
+  getAssociation: async () => ({}) as any,
+  getAssociationCategories: async () => [],
+});

package/dist/api.d.ts

@@ -0,0 +1,15 @@
+import { AccountCreated, LCDPApi, PotCreated, TokenObject, AccountAndPotCreated } from "./types";
+interface LCDPApiResponse {
+    [key: string]: string | LCDPApiResponse;
+}
+export declare class LCDPRequest implements LCDPApi {
+    _apiToken: string;
+    _apiUrl: string;
+    constructor(secret: string, apiUrl: string);
+    requestLCDPApi: (endpoint: string, payload: TokenObject, authToken: string, customMethod?: "POST" | "PATCH") => Promise<LCDPApiResponse | void>;
+    createAccount: (payload: TokenObject) => Promise<AccountCreated>;
+    createPot: (payload: TokenObject) => Promise<PotCreated>;
+    createAccountAndPot: (payload: TokenObject) => Promise<AccountAndPotCreated>;
+    updatePot: (payload: TokenObject) => Promise<void>;
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { LCDPRequest } from "./api";
+import { LoadLCDP } from "./types";
+export * from "./types";
+export declare const loadLCDP: LoadLCDP;
+export declare const requestLCDP: (secret: string, apiUrl?: string) => LCDPRequest;