tally-sdk 0.1.0 → 0.2.1

package/test/hook.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createTallyFetch } from "../src/hook.js";
-import type { Store, PaymentPayload } from "../src/types.js";
-
-function createMockStore(): Store {
-  const inserts: PaymentPayload[] = [];
-  return {
-    insert: vi.fn(async (p: PaymentPayload) => { inserts.push(p); }),
-    list: vi.fn(async () => []),
-    get: vi.fn(async () => null),
-    close: vi.fn(async () => {}),
-  };
-}
-
-describe("createTallyFetch", () => {
-  let store: Store;
-
-  beforeEach(() => {
-    store = createMockStore();
-  });
-
-  it("passes through non-payment responses", async () => {
-    const mockFetch = vi.fn(async () => new Response("ok", { status: 200 }));
-    const tallyFetch = createTallyFetch(mockFetch, store);
-
-    const res = await tallyFetch("https://api.example.com/data");
-    expect(res.status).toBe(200);
-    expect(store.insert).not.toHaveBeenCalled();
-  });
-
-  it("extracts PaymentPayload from response with x-facilitator header", async () => {
-    const paymentPayload = {
-      requestId: "req-1",
-      fromAddress: "0xsender",
-      toAddress: "0xreceiver",
-      amount: "1.50",
-      asset: "USDC",
-      chainId: "eip155:8453",
-      txHash: "0xtx",
-      timestamp: Date.now(),
-    };
-
-    const mockFetch = vi.fn(async () =>
-      Response.json(paymentPayload, {
-        status: 200,
-        headers: { "x-facilitator": "dexter", "x-request-id": "req-1" },
-      })
-    );
-
-    const tallyFetch = createTallyFetch(mockFetch, store, { facilitator: "dexter" });
-    await tallyFetch("https://api.example.com/pay");
-
-    expect(store.insert).toHaveBeenCalledTimes(1);
-    const inserted = (store.insert as ReturnType<typeof vi.fn>).mock.calls[0][0] as PaymentPayload;
-    expect(inserted.facilitator).toBe("dexter");
-    expect(inserted.amount).toBe("1.50");
-    expect(inserted.chainId).toBe("eip155:8453");
-  });
-
-  it("generates an id when none is in the response", async () => {
-    const mockFetch = vi.fn(async () =>
-      Response.json({ amount: "5.00" }, {
-        status: 200,
-        headers: { "x-facilitator": "dexter", "x-request-id": "req-2" },
-      })
-    );
-
-    const tallyFetch = createTallyFetch(mockFetch, store, { facilitator: "dexter" });
-    await tallyFetch("https://api.example.com/pay");
-
-    expect(store.insert).toHaveBeenCalledTimes(1);
-    const inserted = (store.insert as ReturnType<typeof vi.fn>).mock.calls[0][0] as PaymentPayload;
-    expect(inserted.id).toBeDefined();
-    expect(inserted.id.length).toBeGreaterThan(0);
-  });
-
-  it("does not store on error responses", async () => {
-    const mockFetch = vi.fn(async () =>
-      Response.json({ error: "not found" }, { status: 404 })
-    );
-
-    const tallyFetch = createTallyFetch(mockFetch, store);
-    const res = await tallyFetch("https://api.example.com/nope");
-    expect(res.status).toBe(404);
-    expect(store.insert).not.toHaveBeenCalled();
-  });
-});

package/test/index.test.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createTally } from "../src/index.js";
-
-describe("createTally", () => {
-  it("returns a TallyClient with a store", () => {
-    const tally = createTally({ facilitator: "dexter" });
-    expect(tally.fetch).toBeDefined();
-    expect(tally.wrap).toBeDefined();
-    expect(tally.unwrap).toBeDefined();
-    expect(tally.store).toBeDefined();
-    expect(tally.close).toBeDefined();
-    tally.close();
-  });
-
-  it("accepts a custom store", () => {
-    const customStore = {
-      insert: async () => {},
-      list: async () => [],
-      get: async () => null,
-      close: async () => {},
-    };
-    const tally = createTally({ facilitator: "dexter", store: customStore });
-    expect(tally.store).toBe(customStore);
-    tally.close();
-  });
-
-  it("wrap and unwrap monkey-patches and restores globalThis.fetch", () => {
-    const originalFetch = globalThis.fetch;
-    const tally = createTally({ facilitator: "dexter" });
-    tally.wrap();
-    expect(globalThis.fetch).not.toBe(originalFetch);
-    tally.unwrap();
-    expect(globalThis.fetch).toBe(originalFetch);
-    tally.close();
-  });
-});

package/test/integration.test.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { createTally } from "../src/index.js";
-import { SqliteStore } from "../src/store.js";
-import type { Store } from "../src/types.js";
-
-describe("integration", () => {
-  let store: Store;
-
-  afterEach(async () => {
-    await store.close();
-  });
-
-  it("captures a payment end-to-end", async () => {
-    const tally = createTally({ facilitator: "dexter" });
-    store = tally.store;
-
-    // Verify store is ready
-    const list = await tally.store.list();
-    expect(list).toEqual([]);
-
-    tally.close();
-  });
-
-  it("manual pipeline: hook captures, store persists", async () => {
-    const customStore = new SqliteStore(":memory:");
-    store = customStore;
-
-    const fetchSpy = async () =>
-      Response.json(
-        { requestId: "req-int", amount: "3.00", asset: "USDC", chainId: "eip155:1", txHash: "0xint" },
-        { status: 200, headers: { "x-facilitator": "dexter", "x-request-id": "req-int" } }
-      );
-
-    const { createTallyFetch } = await import("../src/hook.js");
-    const tallyFetch = createTallyFetch(fetchSpy, customStore, { facilitator: "dexter" });
-
-    await tallyFetch("https://api.example.com/pay");
-
-    const all = await customStore.list();
-    expect(all).toHaveLength(1);
-    expect(all[0].amount).toBe("3.00");
-    expect(all[0].facilitator).toBe("dexter");
-  });
-});

package/test/store.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { SqliteStore } from "../src/store.js";
-import type { PaymentPayload } from "../src/types.js";
-
-function makePayload(overrides?: Partial<PaymentPayload>): PaymentPayload {
-  return {
-    id: overrides?.id ?? "test-1",
-    facilitator: overrides?.facilitator ?? "dexter",
-    requestId: "req-1",
-    fromAddress: "0xsender",
-    toAddress: "0xreceiver",
-    amount: "10.00",
-    asset: "USDC",
-    chainId: "eip155:1",
-    txHash: "0xtx",
-    timestamp: Date.now(),
-    ...overrides,
-  };
-}
-
-describe("SqliteStore", () => {
-  let store: SqliteStore;
-
-  beforeEach(() => {
-    store = new SqliteStore(":memory:");
-  });
-
-  afterEach(() => {
-    store.close();
-  });
-
-  it("inserts and retrieves a payment", async () => {
-    const payload = makePayload();
-    await store.insert(payload);
-    const result = await store.get(payload.id);
-    expect(result).not.toBeNull();
-    expect(result!.id).toBe(payload.id);
-    expect(result!.amount).toBe("10.00");
-  });
-
-  it("returns null for unknown id", async () => {
-    const result = await store.get("nonexistent");
-    expect(result).toBeNull();
-  });
-
-  it("lists payments ordered by created_at desc", async () => {
-    const p1 = makePayload({ id: "1", timestamp: 1000 });
-    const p2 = makePayload({ id: "2", timestamp: 2000 });
-    await store.insert(p1);
-    await store.insert(p2);
-    const all = await store.list();
-    expect(all).toHaveLength(2);
-    expect(all[0].id).toBe("2"); // newest first
-  });
-
-  it("filters by facilitator", async () => {
-    await store.insert(makePayload({ id: "1", facilitator: "dexter" }));
-    await store.insert(makePayload({ id: "2", facilitator: "coinbase-cdp" }));
-    const filtered = await store.list({ facilitator: "dexter" });
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0].facilitator).toBe("dexter");
-  });
-
-  it("paginates with limit and offset", async () => {
-    for (let i = 0; i < 10; i++) {
-      await store.insert(makePayload({ id: `p${i}`, timestamp: i }));
-    }
-    const page = await store.list({ limit: 3, offset: 0 });
-    expect(page).toHaveLength(3);
-  });
-
-  it("handles metadata serialization", async () => {
-    const payload = makePayload({ metadata: { foo: "bar", num: 42 } });
-    await store.insert(payload);
-    const result = await store.get(payload.id);
-    expect(result!.metadata).toEqual({ foo: "bar", num: 42 });
-  });
-
-  it("ignores duplicate inserts (idempotency)", async () => {
-    const payload = makePayload({ id: "dup-1" });
-    await store.insert(payload);
-    await store.insert(payload);
-    const result = await store.get("dup-1");
-    expect(result).not.toBeNull();
-    const all = await store.list();
-    expect(all).toHaveLength(1);
-  });
-});

package/test/types.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type { PaymentPayload, Store, TallyConfig, TallyClient } from "../src/types.js";
-
-describe("types", () => {
-  it("PaymentPayload can be constructed", () => {
-    const payload: PaymentPayload = {
-      id: "abc-123",
-      facilitator: "dexter",
-      requestId: "req-1",
-      fromAddress: "0xsender",
-      toAddress: "0xreceiver",
-      amount: "10.00",
-      asset: "USDC",
-      chainId: "eip155:1",
-      txHash: "0xtx",
-      timestamp: Date.now(),
-    };
-    expect(payload.amount).toBe("10.00");
-  });
-
-  it("Store interface is structurally typed", () => {
-    const store: Store = {
-      insert: async () => {},
-      list: async () => [],
-      get: async () => null,
-      close: async () => {},
-    };
-    expect(store).toBeDefined();
-  });
-});