@accounter/scraper-app 0.0.1

package/src/server/check-accounts.ts

@@ -0,0 +1,79 @@
+import type { IsracardCardsTransactionsList } from '@accounter/modern-poalim-scraper';
+import type { CalPayload } from './payload-schemas/cal.schema.js';
+import type { DiscountPayload } from './payload-schemas/discount.schema.js';
+import type { MaxPayload } from './payload-schemas/max.schema.js';
+import type { PoalimForeignPayload } from './payload-schemas/poalim-foreign.schema.js';
+import type { PoalimIlsPayload } from './payload-schemas/poalim-ils.schema.js';
+import type { PoalimSwiftPayload } from './payload-schemas/poalim-swift.schema.js';
+import type { AccountRecord } from './vault.js';
+
+export type SourceType = 'poalim' | 'discount' | 'isracard' | 'amex' | 'cal' | 'max';
+
+export type ValidatedPayload =
+  | PoalimIlsPayload
+  | PoalimForeignPayload
+  | PoalimSwiftPayload
+  | DiscountPayload
+  | IsracardCardsTransactionsList
+  | CalPayload
+  | MaxPayload;
+
+export type { AccountRecord } from './vault.js';
+
+export type AccountCheckResult = { accepted: string[]; ignored: string[]; unknown: string[] };
+
+export function extractAccountIdentifiers(type: SourceType, payload: ValidatedPayload): string[] {
+  switch (type) {
+    case 'poalim': {
+      if (!('retrievalTransactionData' in payload)) return [];
+      const p = payload as PoalimIlsPayload;
+      return [String(p.retrievalTransactionData.accountNumber)];
+    }
+    case 'discount': {
+      const p = payload as DiscountPayload;
+      return [...new Set(p.map(entry => entry.accountNumber))];
+    }
+    case 'isracard':
+    case 'amex': {
+      const p = payload as IsracardCardsTransactionsList;
+      return p.CardsTransactionsListBean.cardNumberList
+        .map(c => c.match(/\d{4}/)?.[0])
+        .filter((c): c is string => c !== undefined);
+    }
+    case 'cal': {
+      const p = payload as CalPayload;
+      return [...new Set(p.map(entry => entry.card))];
+    }
+    case 'max': {
+      const p = payload as MaxPayload;
+      return [...new Set(p.map(account => account.accountNumber))];
+    }
+  }
+}
+
+export function checkAccounts(
+  type: SourceType,
+  payload: ValidatedPayload,
+  known: AccountRecord[],
+): AccountCheckResult {
+  const identifiers = extractAccountIdentifiers(type, payload);
+  const accepted: string[] = [];
+  const ignored: string[] = [];
+  const unknown: string[] = [];
+
+  for (const id of identifiers) {
+    const record = known.find(a => a.sourceType === type && a.accountNumber === id);
+    if (!record) {
+      unknown.push(id);
+    } else if (record.status === 'ignored') {
+      ignored.push(id);
+    } else if (record.status === 'accepted') {
+      accepted.push(id);
+    } else {
+      // 'pending' and any future unrecognized status blocks the run
+      unknown.push(id);
+    }
+  }
+
+  return { accepted, ignored, unknown };
+}

package/src/server/filter-payload.ts

@@ -0,0 +1,145 @@
+import type { z } from 'zod';
+import type { IsracardCardsTransactionsList } from '@accounter/modern-poalim-scraper';
+import type { SourceType, ValidatedPayload } from './check-accounts.js';
+import type { CalPayload } from './payload-schemas/cal.schema.js';
+import type { DiscountPayload } from './payload-schemas/discount.schema.js';
+import type { MaxPayload } from './payload-schemas/max.schema.js';
+import type { PoalimForeignPayload } from './payload-schemas/poalim-foreign.schema.js';
+import type { PoalimIlsPayload } from './payload-schemas/poalim-ils.schema.js';
+import type { PoalimSwiftPayload } from './payload-schemas/poalim-swift.schema.js';
+import type {
+  CalAccountSchema,
+  DiscountAccountSchema,
+  IsracardAmexAccountSchema,
+  MaxAccountSchema,
+  PoalimAccountSchema,
+} from './vault.js';
+
+export type FilterableCreds =
+  | z.infer<typeof PoalimAccountSchema>
+  | z.infer<typeof IsracardAmexAccountSchema>
+  | z.infer<typeof CalAccountSchema>
+  | z.infer<typeof MaxAccountSchema>
+  | z.infer<typeof DiscountAccountSchema>;
+
+function effectiveSet(
+  accepted: string[] | undefined,
+  ignored: string[] | undefined,
+  all: string[],
+): Set<string> {
+  const base = accepted?.length ? accepted : all;
+  const ignoredSet = new Set(ignored ?? []);
+  return new Set(base.filter(c => !ignoredSet.has(c)));
+}
+
+function filterIsracardAmex(
+  payload: IsracardCardsTransactionsList,
+  accepted: string[] | undefined,
+  ignored: string[] | undefined,
+): IsracardCardsTransactionsList {
+  const bean = payload.CardsTransactionsListBean;
+  const allCards = bean.cardNumberList.map(c => c.match(/\d{4}/)?.[0]);
+
+  const allowed = effectiveSet(accepted, ignored, allCards.filter(Boolean) as string[]);
+
+  const filteredBean: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(bean)) {
+    if (/^Index\d+$/.test(key)) {
+      const card = allCards[Number(key.slice(5))]; // 'Index0' → 0 → cardNumbers[0]
+      if (!card || !allowed.has(card)) {
+        continue;
+      }
+    }
+    filteredBean[key] = val;
+  }
+
+  return {
+    ...payload,
+    CardsTransactionsListBean:
+      filteredBean as IsracardCardsTransactionsList['CardsTransactionsListBean'],
+  };
+}
+
+export function filterPayload(
+  type: SourceType,
+  payload: ValidatedPayload,
+  creds: FilterableCreds,
+): ValidatedPayload {
+  switch (type) {
+    case 'isracard':
+    case 'amex': {
+      const p = payload as IsracardCardsTransactionsList;
+      const opts = (creds as z.infer<typeof IsracardAmexAccountSchema>).options;
+      return filterIsracardAmex(
+        p,
+        opts?.acceptedCardNumbers,
+        opts?.ignoredCardNumbers,
+      ) as IsracardCardsTransactionsList;
+    }
+
+    case 'cal': {
+      const p = payload as CalPayload;
+      const opts = (creds as z.infer<typeof CalAccountSchema>).options;
+      const allCards = [...new Set(p.map(e => e.card))];
+      const allowed = effectiveSet(opts?.acceptedCardNumbers, opts?.ignoredCardNumbers, allCards);
+      return p.filter(e => allowed.has(e.card));
+    }
+
+    case 'max': {
+      const p = payload as MaxPayload;
+      const opts = (creds as z.infer<typeof MaxAccountSchema>).options;
+      const allAccounts = [...new Set(p.map(e => e.accountNumber))];
+      const allowed = effectiveSet(
+        opts?.acceptedCardNumbers,
+        opts?.ignoredCardNumbers,
+        allAccounts,
+      );
+      return p.filter(e => allowed.has(e.accountNumber));
+    }
+
+    case 'poalim': {
+      const opts = (creds as z.infer<typeof PoalimAccountSchema>).options;
+      // PoalimIls has retrievalTransactionData; Foreign has balancesAndLimitsDataList; Swift has swiftsList
+      if ('retrievalTransactionData' in payload) {
+        const p = payload as PoalimIlsPayload;
+        const { accountNumber, branchNumber } = p.retrievalTransactionData;
+        const allAccounts = [String(accountNumber)];
+        const allBranches = [String(branchNumber)];
+        const allowedAccounts = effectiveSet(
+          opts?.acceptedAccountNumbers,
+          opts?.ignoredAccountNumbers,
+          allAccounts,
+        );
+        const allowedBranches = effectiveSet(
+          opts?.acceptedBranchNumbers,
+          opts?.ignoredBranchNumbers,
+          allBranches,
+        );
+        if (
+          !allowedAccounts.has(String(accountNumber)) ||
+          !allowedBranches.has(String(branchNumber))
+        ) {
+          return { ...p, transactions: [] };
+        }
+        return p;
+      }
+      if ('balancesAndLimitsDataList' in payload) {
+        // Foreign payloads carry no account/branch identifiers — account-level filtering
+        // is handled by the caller, which correlates each Foreign payload with its
+        // positionally-matched ILS payload (which does carry the identifiers).
+        return payload as PoalimForeignPayload;
+      }
+      if ('swiftsList' in payload) {
+        // Swift payloads carry no account/branch identifiers — same as Foreign above.
+        return payload as PoalimSwiftPayload;
+      }
+      return payload;
+    }
+
+    case 'discount': {
+      // No filter options for discount
+      const p = payload as DiscountPayload;
+      return p;
+    }
+  }
+}

package/src/server/graphql/client.ts

@@ -0,0 +1,103 @@
+import { GraphQLClient } from 'graphql-request';
+import type { IsracardCardsTransactionsList } from '@accounter/modern-poalim-scraper';
+import type { ScraperUploadResult } from '../gql/index.js';
+import type { CalPayload } from '../payload-schemas/cal.schema.js';
+import type { CurrencyRatesPayload } from '../payload-schemas/currency-rates.schema.js';
+import type { DiscountPayload } from '../payload-schemas/discount.schema.js';
+import type { MaxPayload } from '../payload-schemas/max.schema.js';
+import type { PoalimForeignPayload } from '../payload-schemas/poalim-foreign.schema.js';
+import type { PoalimIlsPayload } from '../payload-schemas/poalim-ils.schema.js';
+import type { PoalimSwiftPayload } from '../payload-schemas/poalim-swift.schema.js';
+import {
+  amexVars,
+  calVars,
+  currencyRatesVars,
+  discountVars,
+  isracardVars,
+  maxVars,
+  poalimForeignVars,
+  poalimIlsVars,
+  poalimSwiftVars,
+  UPLOAD_AMEX,
+  UPLOAD_CAL,
+  UPLOAD_CURRENCY_RATES,
+  UPLOAD_DISCOUNT,
+  UPLOAD_ISRACARD,
+  UPLOAD_MAX,
+  UPLOAD_POALIM_FOREIGN,
+  UPLOAD_POALIM_ILS,
+  UPLOAD_POALIM_SWIFT,
+} from './mutations.js';
+
+type GqlResponse<K extends string> = Record<K, ScraperUploadResult>;
+
+function extractResult<K extends string>(data: GqlResponse<K>, key: K): ScraperUploadResult {
+  const result = data[key];
+  if (!result) throw new Error(`GraphQL response missing field: ${key}`);
+  return result;
+}
+
+export type { ScraperUploadResult };
+
+export function createUploadClient(serverUrl: string, apiKey: string) {
+  const gql = new GraphQLClient(serverUrl, {
+    headers: { 'X-API-Key': apiKey },
+  });
+
+  async function request<K extends string>(
+    doc: string,
+    vars: Record<string, unknown>,
+    key: K,
+  ): Promise<ScraperUploadResult> {
+    const data = await gql.request<GqlResponse<K>>(doc, vars);
+    return extractResult(data, key);
+  }
+
+  return {
+    async uploadPoalimIls(payload: PoalimIlsPayload): Promise<ScraperUploadResult> {
+      return request(UPLOAD_POALIM_ILS, poalimIlsVars(payload), 'uploadPoalimIlsTransactions');
+    },
+
+    async uploadPoalimForeign(payload: PoalimForeignPayload): Promise<ScraperUploadResult> {
+      return request(
+        UPLOAD_POALIM_FOREIGN,
+        poalimForeignVars(payload),
+        'uploadPoalimForeignTransactions',
+      );
+    },
+
+    async uploadPoalimSwift(payload: PoalimSwiftPayload): Promise<ScraperUploadResult> {
+      return request(
+        UPLOAD_POALIM_SWIFT,
+        poalimSwiftVars(payload),
+        'uploadPoalimSwiftTransactions',
+      );
+    },
+
+    async uploadIsracard(payloads: IsracardCardsTransactionsList[]): Promise<ScraperUploadResult> {
+      return request(UPLOAD_ISRACARD, isracardVars(payloads), 'uploadIsracardTransactions');
+    },
+
+    async uploadAmex(payloads: IsracardCardsTransactionsList[]): Promise<ScraperUploadResult> {
+      return request(UPLOAD_AMEX, amexVars(payloads), 'uploadAmexTransactions');
+    },
+
+    async uploadCal(payload: CalPayload): Promise<ScraperUploadResult> {
+      return request(UPLOAD_CAL, calVars(payload), 'uploadCalTransactions');
+    },
+
+    async uploadDiscount(payload: DiscountPayload): Promise<ScraperUploadResult> {
+      return request(UPLOAD_DISCOUNT, discountVars(payload), 'uploadDiscountTransactions');
+    },
+
+    async uploadMax(payload: MaxPayload): Promise<ScraperUploadResult> {
+      return request(UPLOAD_MAX, maxVars(payload), 'uploadMaxTransactions');
+    },
+
+    async uploadCurrencyRates(payload: CurrencyRatesPayload): Promise<ScraperUploadResult> {
+      return request(UPLOAD_CURRENCY_RATES, currencyRatesVars(payload), 'uploadCurrencyRates');
+    },
+  };
+}
+
+export type UploadClient = ReturnType<typeof createUploadClient>;