@accounter/scraper-app 0.0.1

package/src/server/__tests__/graphql-client.test.ts

@@ -0,0 +1,508 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest';
+import { setupServer } from 'msw/node';
+import { graphql, HttpResponse } from 'msw';
+import { createUploadClient } from '../graphql/client.js';
+
+const MOCK_URL = 'http://localhost:4000/graphql';
+const MOCK_API_KEY = 'test-api-key-123';
+const MOCK_RESULT = {
+  inserted: 2,
+  skipped: 1,
+  insertedIds: ['id-1', 'id-2'],
+  insertedTransactions: [],
+  changedTransactions: [],
+};
+
+// ── MSW server ────────────────────────────────────────────────────────────────
+
+let lastAuthHeader: string | null = null;
+let lastMutationName: string | null = null;
+let lastVariables: Record<string, unknown> = {};
+
+const server = setupServer(
+  graphql.link(MOCK_URL).mutation('UploadPoalimIlsTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadPoalimIlsTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadPoalimIlsTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadPoalimForeignTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadPoalimForeignTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadPoalimForeignTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadPoalimSwiftTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadPoalimSwiftTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadPoalimSwiftTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadIsracardTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadIsracardTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadIsracardTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadAmexTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadAmexTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadAmexTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadCalTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadCalTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadCalTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadDiscountTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadDiscountTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadDiscountTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadMaxTransactions', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadMaxTransactions';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadMaxTransactions: MOCK_RESULT } });
+  }),
+
+  graphql.link(MOCK_URL).mutation('UploadCurrencyRates', ({ request, variables }) => {
+    lastAuthHeader = request.headers.get('X-API-Key');
+    lastMutationName = 'UploadCurrencyRates';
+    lastVariables = variables as Record<string, unknown>;
+    return HttpResponse.json({ data: { uploadCurrencyRates: MOCK_RESULT } });
+  }),
+);
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'error' }));
+afterEach(() => {
+  server.resetHandlers();
+  lastAuthHeader = null;
+  lastMutationName = null;
+  lastVariables = {};
+});
+afterAll(() => server.close());
+
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+
+const ILS_PAYLOAD = {
+  transactions: [
+    {
+      activityDescription: 'Credit',
+      activityTypeCode: 1,
+      eventAmount: 100,
+      eventDate: 20240101,
+      serialNumber: 1,
+      transactionType: 'REGULAR' as const,
+      currentBalance: 5000,
+      referenceNumber: 42,
+    },
+  ],
+  retrievalTransactionData: { accountNumber: 100000, branchNumber: 600, bankNumber: 12 },
+};
+
+const FOREIGN_PAYLOAD = {
+  balancesAndLimitsDataList: [
+    {
+      currencySwiftCode: 'USD',
+      currencyCode: 1,
+      transactions: [
+        {
+          activityDescription: 'Transfer',
+          activityTypeCode: 1,
+          eventAmount: 500,
+          currencySwiftCode: 'USD',
+          currencyRate: 3.7,
+          currentBalance: 1000,
+          referenceNumber: 99,
+          transactionType: 'REGULAR',
+        },
+      ],
+    },
+  ],
+};
+
+const SWIFT_PAYLOAD = {
+  swiftsList: [
+    {
+      startDate: 20240101,
+      swiftStatusCode: 'OK',
+      amount: 1000,
+      currencyCodeCatenatedKey: 'USD',
+      chargePartyName: 'Test',
+      referenceNumber: 'REF-1',
+      transferCatenatedId: 'TID-1',
+    },
+  ],
+};
+
+const ISRACARD_PAYLOAD = [
+  {
+    Header: { Status: '1', Message: null },
+    CardsTransactionsListBean: {
+      cardNumberList: ['card 7567'],
+      Index0: {
+        '@AllCards': 'AllCards',
+        CurrentCardTransactions: [
+          {
+            txnIsrael: [
+              {
+                cardIndex: '0',
+                supplierName: 'Shop',
+                dealSum: '100',
+                fullPurchaseDate: '01/01/2024',
+                purchaseDate: '01/01/2024',
+                voucherNumber: '1234',
+                voucherNumberRatz: '5678',
+              },
+            ],
+            txnAbroad: null,
+          },
+        ],
+      },
+    },
+  },
+];
+
+const CAL_PAYLOAD = [
+  {
+    card: '1234',
+    month: '2024-01',
+    transactions: [
+      {
+        trnIntId: 'TRN-1',
+        merchantName: 'Store',
+        trnAmt: 150,
+        trnPurchaseDate: '2024-01-15',
+        trnCurrencySymbol: 'ILS',
+        trnType: 'normal',
+        debCrdDate: '2024-02-01',
+        amtBeforeConvAndIndex: 150,
+        debCrdCurrencySymbol: 'ILS',
+      },
+    ],
+  },
+];
+
+const DISCOUNT_PAYLOAD = [
+  {
+    accountNumber: 'ACC-001',
+    month: '2024-01',
+    balance: 5000,
+    transactions: [
+      {
+        OperationDate: '20240101',
+        ValueDate: '20240101',
+        OperationCode: '1',
+        OperationDescription: 'Credit',
+        OperationAmount: 1000,
+        BalanceAfterOperation: 5000,
+        OperationNumber: 1,
+        OperationDescription2: '',
+        OperationDescription3: '',
+        OperationBranch: 1,
+        OperationBank: 1,
+        Channel: 'web',
+        ChannelName: 'Web',
+        InstituteCode: '1',
+        BranchTreasuryNumber: '1',
+        Urn: 'urn-1',
+        OperationDetailsServiceName: '',
+        CommissionChannelCode: '',
+        CommissionChannelName: '',
+        CommissionTypeName: '',
+        BusinessDayDate: '20240101',
+        EventName: '',
+        CategoryCode: 1,
+        CategoryDescCode: 1,
+        CategoryDescription: '',
+        OperationDescriptionToDisplay: 'Credit',
+        OperationOrder: 1,
+        IsLastSeen: false,
+      },
+    ],
+  },
+];
+
+const MAX_PAYLOAD = [
+  {
+    accountNumber: '7',
+    txns: [
+      {
+        cardIndex: 7,
+        categoryId: 1,
+        merchantName: 'Store',
+        originalAmount: 200,
+        originalCurrency: 'ILS',
+        purchaseDate: '2024-01-15',
+        uid: 'UID-1',
+        planName: 'regular',
+        planTypeId: 1,
+      },
+    ],
+  },
+];
+
+const CURRENCY_RATES_PAYLOAD = [
+  { date: '2024-01-01', currency: 'USD' as const, rate: 3.712 },
+  { date: '2024-01-01', currency: 'EUR' as const, rate: 4.01 },
+  { date: '2024-01-02', currency: 'USD' as const, rate: 3.72 },
+];
+
+// ── Helper ────────────────────────────────────────────────────────────────────
+
+function client() {
+  return createUploadClient(MOCK_URL, MOCK_API_KEY);
+}
+
+// ── X-API-Key header ──────────────────────────────────────────────────────
+
+describe('X-API-Key header', () => {
+  it('sends API key on every request', async () => {
+    await client().uploadPoalimIls(ILS_PAYLOAD);
+    expect(lastAuthHeader).toBe(MOCK_API_KEY);
+  });
+
+  it('uses the apiKey passed to createUploadClient', async () => {
+    const c = createUploadClient(MOCK_URL, 'different-key');
+    await c.uploadPoalimIls(ILS_PAYLOAD);
+    expect(lastAuthHeader).toBe('different-key');
+  });
+});
+
+// ── Mutation names and variables ──────────────────────────────────────────────
+
+describe('uploadPoalimIls', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadPoalimIls(ILS_PAYLOAD);
+    expect(lastMutationName).toBe('UploadPoalimIlsTransactions');
+  });
+
+  it('embeds accountNumber and branchNumber inside each transaction row', async () => {
+    await client().uploadPoalimIls(ILS_PAYLOAD);
+    const txns = lastVariables['transactions'] as unknown[];
+    expect(Array.isArray(txns)).toBe(true);
+    expect((txns[0] as Record<string, unknown>)['accountNumber']).toBe(100000);
+    expect((txns[0] as Record<string, unknown>)['branchNumber']).toBe(600);
+  });
+
+  it('sends transactions array as variable', async () => {
+    await client().uploadPoalimIls(ILS_PAYLOAD);
+    expect(Array.isArray(lastVariables['transactions'])).toBe(true);
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadPoalimIls(ILS_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadPoalimForeign', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadPoalimForeign(FOREIGN_PAYLOAD);
+    expect(lastMutationName).toBe('UploadPoalimForeignTransactions');
+  });
+
+  it('flattens currency entries into a single transactions array', async () => {
+    await client().uploadPoalimForeign(FOREIGN_PAYLOAD);
+    const txns = lastVariables['transactions'] as unknown[];
+    expect(Array.isArray(txns)).toBe(true);
+    expect(txns).toHaveLength(1);
+    expect((txns[0] as Record<string, unknown>)['currencySwiftCode']).toBe('USD');
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadPoalimForeign(FOREIGN_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadPoalimSwift', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadPoalimSwift(SWIFT_PAYLOAD);
+    expect(lastMutationName).toBe('UploadPoalimSwiftTransactions');
+  });
+
+  it('sends swifts variable', async () => {
+    await client().uploadPoalimSwift(SWIFT_PAYLOAD);
+    expect(Array.isArray(lastVariables['swifts'])).toBe(true);
+    expect(lastVariables['swifts'] as unknown[]).toHaveLength(1);
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadPoalimSwift(SWIFT_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadIsracard', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadIsracard(ISRACARD_PAYLOAD);
+    expect(lastMutationName).toBe('UploadIsracardTransactions');
+  });
+
+  it('flattens txnIsrael/txnAbroad entries with card attached', async () => {
+    await client().uploadIsracard(ISRACARD_PAYLOAD);
+    const txns = lastVariables['transactions'] as unknown[];
+    expect(Array.isArray(txns)).toBe(true);
+    expect(txns).toHaveLength(1);
+    expect((txns[0] as Record<string, unknown>)['card']).toBe('7567');
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadIsracard(ISRACARD_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadAmex', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadAmex(ISRACARD_PAYLOAD);
+    expect(lastMutationName).toBe('UploadAmexTransactions');
+  });
+
+  it('flattens with card attached', async () => {
+    await client().uploadAmex(ISRACARD_PAYLOAD);
+    const txns = lastVariables['transactions'] as unknown[];
+    expect((txns[0] as Record<string, unknown>)['card']).toBe('7567');
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadAmex(ISRACARD_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadCal', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadCal(CAL_PAYLOAD);
+    expect(lastMutationName).toBe('UploadCalTransactions');
+  });
+
+  it('flattens to per-transaction rows with card attached', async () => {
+    await client().uploadCal(CAL_PAYLOAD);
+    const txns = lastVariables['transactions'] as unknown[];
+    expect(Array.isArray(txns)).toBe(true);
+    expect(txns).toHaveLength(1);
+    expect((txns[0] as Record<string, unknown>)['card']).toBe('1234');
+    expect((txns[0] as Record<string, unknown>)['trnIntId']).toBe('TRN-1');
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadCal(CAL_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadDiscount', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadDiscount(DISCOUNT_PAYLOAD);
+    expect(lastMutationName).toBe('UploadDiscountTransactions');
+  });
+
+  it('flattens to per-transaction rows with accountNumber attached', async () => {
+    await client().uploadDiscount(DISCOUNT_PAYLOAD);
+    const txns = lastVariables['transactions'] as unknown[];
+    expect(Array.isArray(txns)).toBe(true);
+    expect(txns).toHaveLength(1);
+    expect((txns[0] as Record<string, unknown>)['accountNumber']).toBe('ACC-001');
+    expect((txns[0] as Record<string, unknown>)['urn']).toBe('urn-1');
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadDiscount(DISCOUNT_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadMax', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadMax(MAX_PAYLOAD);
+    expect(lastMutationName).toBe('UploadMaxTransactions');
+  });
+
+  it('flattens to per-transaction rows', async () => {
+    await client().uploadMax(MAX_PAYLOAD);
+    const txns = lastVariables['transactions'] as unknown[];
+    expect(Array.isArray(txns)).toBe(true);
+    expect(txns).toHaveLength(1);
+    expect((txns[0] as Record<string, unknown>)['uid']).toBe('UID-1');
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadMax(MAX_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+describe('uploadCurrencyRates', () => {
+  it('sends correct mutation name', async () => {
+    await client().uploadCurrencyRates(CURRENCY_RATES_PAYLOAD);
+    expect(lastMutationName).toBe('UploadCurrencyRates');
+  });
+
+  it('pivots { date, currency, rate }[] into { exchangeDate, usd, eur, ... }[] rows', async () => {
+    await client().uploadCurrencyRates(CURRENCY_RATES_PAYLOAD);
+    const rates = lastVariables['rates'] as Array<Record<string, unknown>>;
+    expect(Array.isArray(rates)).toBe(true);
+    // Two distinct dates in fixture
+    expect(rates).toHaveLength(2);
+    const jan1 = rates.find(r => r['exchangeDate'] === '2024-01-01')!;
+    expect(jan1['usd']).toBe(3.712);
+    expect(jan1['eur']).toBe(4.01);
+    const jan2 = rates.find(r => r['exchangeDate'] === '2024-01-02')!;
+    expect(jan2['usd']).toBe(3.72);
+    expect(jan2['eur']).toBeUndefined();
+  });
+
+  it('returns UploadResult', async () => {
+    const result = await client().uploadCurrencyRates(CURRENCY_RATES_PAYLOAD);
+    expect(result).toEqual(MOCK_RESULT);
+  });
+});
+
+// ── Error handling ────────────────────────────────────────────────────────────
+
+describe('error responses', () => {
+  it('throws on 4xx HTTP response', async () => {
+    server.use(
+      graphql.link(MOCK_URL).mutation('UploadPoalimIlsTransactions', () => {
+        return HttpResponse.json({ errors: [{ message: 'Unauthorized' }] }, { status: 401 });
+      }),
+    );
+    await expect(client().uploadPoalimIls(ILS_PAYLOAD)).rejects.toThrow();
+  });
+
+  it('throws on 5xx HTTP response', async () => {
+    server.use(
+      graphql.link(MOCK_URL).mutation('UploadPoalimIlsTransactions', () => {
+        return HttpResponse.json(
+          { errors: [{ message: 'Internal Server Error' }] },
+          { status: 500 },
+        );
+      }),
+    );
+    await expect(client().uploadPoalimIls(ILS_PAYLOAD)).rejects.toThrow();
+  });
+
+  it('throws on GraphQL-level errors', async () => {
+    server.use(
+      graphql.link(MOCK_URL).mutation('UploadPoalimIlsTransactions', () => {
+        return HttpResponse.json({
+          errors: [{ message: 'Not authenticated', extensions: { code: 'UNAUTHENTICATED' } }],
+        });
+      }),
+    );
+    await expect(client().uploadPoalimIls(ILS_PAYLOAD)).rejects.toThrow();
+  });
+});

package/src/server/__tests__/healthz.test.ts

@@ -0,0 +1,22 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { FastifyInstance } from 'fastify';
+import { buildServer } from '../index.js';
+
+let app: FastifyInstance;
+
+beforeEach(async () => {
+  app = await buildServer();
+  await app.ready();
+});
+
+afterEach(async () => {
+  await app.close();
+});
+
+describe('GET /healthz', () => {
+  it('returns 200 with { ok: true }', async () => {
+    const res = await app.inject({ method: 'GET', url: '/healthz' });
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ ok: true });
+  });
+});

package/src/server/__tests__/history.test.ts

@@ -0,0 +1,111 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { appendRun, clearHistory, readHistory } from '../history.js';
+import type { RunRecord } from '../../shared/types.js';
+
+function makeRecord(i: number): RunRecord {
+  return {
+    id: `run-${i}`,
+    startedAt: new Date(Date.now() + i * 1000).toISOString(),
+    completedAt: new Date(Date.now() + i * 1000 + 500).toISOString(),
+    totalInserted: i,
+    totalSkipped: 0,
+    errorCount: 0,
+    sources: [],
+  };
+}
+
+let tmpDir: string;
+let filePath: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'history-test-'));
+  filePath = join(tmpDir, 'history.json');
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe('readHistory', () => {
+  it('returns [] when file is missing', async () => {
+    expect(await readHistory(filePath)).toEqual([]);
+  });
+
+  it('returns records newest-first after appending 3', async () => {
+    await appendRun(makeRecord(1), filePath);
+    await appendRun(makeRecord(2), filePath);
+    await appendRun(makeRecord(3), filePath);
+
+    const result = await readHistory(filePath);
+    expect(result).toHaveLength(3);
+    expect(result[0]!.id).toBe('run-3');
+    expect(result[1]!.id).toBe('run-2');
+    expect(result[2]!.id).toBe('run-1');
+  });
+
+  it('returns last 100 records when 150 are appended', async () => {
+    for (let i = 1; i <= 150; i++) {
+      await appendRun(makeRecord(i), filePath);
+    }
+    const result = await readHistory(filePath);
+    expect(result).toHaveLength(100);
+    expect(result[0]!.id).toBe('run-150');
+    expect(result[99]!.id).toBe('run-51');
+  });
+});
+
+describe('concurrent writes', () => {
+  it('retains all records when appendRun is called concurrently', async () => {
+    // Fire 10 appends simultaneously — without the queue they would race and
+    // overwrite each other; with it every record must survive.
+    await Promise.all(Array.from({ length: 10 }, (_, i) => appendRun(makeRecord(i + 1), filePath)));
+
+    const result = await readHistory(filePath);
+    expect(result).toHaveLength(10);
+    const ids = new Set(result.map(r => r.id));
+    for (let i = 1; i <= 10; i++) expect(ids.has(`run-${i}`)).toBe(true);
+  });
+});
+
+describe('clearHistory', () => {
+  it('empties the history file', async () => {
+    await appendRun(makeRecord(1), filePath);
+    await clearHistory(filePath);
+    expect(await readHistory(filePath)).toEqual([]);
+  });
+});
+
+describe('saveHistory gate in websocket', () => {
+  it('does not call appendRun when saveHistory is false', async () => {
+    const spy = vi.spyOn(await import('../history.js'), 'appendRun').mockResolvedValue(undefined);
+
+    const { startRun } = await import('../scrape-runner.js');
+    const { _resetRunState } = await import('../scrape-runner.js');
+    _resetRunState();
+
+    const noopEmit = () => {};
+    const task = {
+      sourceId: 'test',
+      nickname: 'test',
+      type: 'discount',
+      run: async () => ({ inserted: 1, skipped: 0, insertedIds: [], insertedTransactions: [], changedTransactions: [] }),
+    };
+
+    const runRecord = await startRun([task], false, noopEmit);
+
+    // Simulate the saveHistory=false branch: appendRun should NOT be called
+    const saveHistory = false;
+    if (saveHistory) {
+      await appendRun(
+        { ...runRecord, startedAt: runRecord.startedAt.toISOString(), completedAt: runRecord.completedAt.toISOString(), sources: [] },
+        filePath,
+      );
+    }
+
+    expect(spy).not.toHaveBeenCalled();
+    spy.mockRestore();
+  });
+});