@accounter/server/dist/server/src/modules/transactions/providers/transactions.provider.js

import { __decorate, __metadata } from "tslib";
import DataLoader from 'dataloader';
import { Injectable, Scope } from 'graphql-modules';
import { DBProvider } from '../../app-providers/db.provider.js';
import { sql } from '@pgtyped/runtime';
import { getCacheInstance } from '../../../shared/helpers/index.js';
const getTransactionsByIds = sql `
    SELECT *
    FROM accounter_schema.transactions
    WHERE id IN $$transactionIds;`;
const getTransactionsByChargeIds = sql `
    SELECT *
    FROM accounter_schema.transactions
    WHERE charge_id IN $$chargeIds;`;
const getTransactionsByMissingRequiredInfo = sql `
    SELECT *
    FROM accounter_schema.transactions
    WHERE business_id IS NULL;`;
const getTransactionsByFilters = sql `
  SELECT t.*
  FROM accounter_schema.transactions t
  LEFT JOIN accounter_schema.charges c
    ON t.charge_id = C.id
  WHERE
    ($isIDs = 0 OR t.id IN $$IDs)
    AND ($fromEventDate ::TEXT IS NULL OR t.event_date::TEXT::DATE >= date_trunc('day', $fromEventDate ::DATE))
    AND ($toEventDate ::TEXT IS NULL OR t.event_date::TEXT::DATE <= date_trunc('day', $toEventDate ::DATE))
    AND ($fromDebitDate ::TEXT IS NULL OR COALESCE(t.debit_date_override, t.debit_date)::TEXT::DATE >= date_trunc('day', $fromDebitDate ::DATE))
    AND ($toDebitDate ::TEXT IS NULL OR COALESCE(t.debit_date_override, t.debit_date)::TEXT::DATE <= date_trunc('day', $toDebitDate ::DATE))
    AND ($isBusinessIDs = 0 OR t.business_id IN $$businessIDs)
    AND ($isOwnerIDs = 0 OR c.owner_id IN $$ownerIDs)
  ORDER BY event_date DESC;
`;
const getSimilarTransactions = sql `
    SELECT t.*, c.owner_id
    FROM accounter_schema.transactions t
    LEFT JOIN accounter_schema.charges c
      ON t.charge_id = c.id
    WHERE (CASE WHEN $withMissingInfo IS TRUE THEN
      business_id IS NULL
   ELSE
      TRUE
   END)
      AND (
        (source_description IS NOT NULL AND source_description <> '' AND source_description = $details)
        OR (counter_account IS NOT NULL AND counter_account <> '' AND counter_account = $counterAccount)
      ) AND c.owner_id = $ownerId;`;
const replaceTransactionsChargeId = sql `
  UPDATE accounter_schema.transactions
  SET charge_id = $assertChargeID
  WHERE charge_id = $replaceChargeID
  RETURNING id;
`;
const updateTransaction = sql `
  UPDATE accounter_schema.transactions
  SET
    account_id = COALESCE(
      $accountId,
      account_id,
      NULL
    ),
    charge_id = COALESCE(
      $chargeId,
      charge_id,
      NULL
    ),
    debit_date_override = COALESCE(
      $debitDate,
      debit_date_override,
      NULL
    ),
    business_id = COALESCE(
      $businessId,
      business_id,
      NULL
    ),
    is_fee = COALESCE(
      $isFee,
      is_fee,
      NULL
    )
  WHERE
    id = $transactionId
  RETURNING *;
`;
let TransactionsProvider = class TransactionsProvider {
    dbProvider;
    cache = getCacheInstance({
        stdTTL: 60 * 5,
    });
    constructor(dbProvider) {
        this.dbProvider = dbProvider;
    }
    async batchTransactionsByIds(ids) {
        const transactions = await getTransactionsByIds.run({
            transactionIds: ids,
        }, this.dbProvider);
        return ids.map(id => {
            const transaction = transactions.find(transaction => transaction.id === id);
            if (!transaction) {
                return new Error(`Transaction ID="${id}" not found`);
            }
            return transaction;
        });
    }
    transactionByIdLoader = new DataLoader((keys) => this.batchTransactionsByIds(keys), {
        cacheKeyFn: id => `transaction-${id}`,
        cacheMap: this.cache,
    });
    async getTransactionsByMissingRequiredInfo() {
        return getTransactionsByMissingRequiredInfo.run(undefined, this.dbProvider).then(res => res.map(t => {
            this.cache.set(`transaction-${t.id}`, t);
            return t;
        }));
    }
    async batchTransactionsByChargeIDs(chargeIds) {
        const transactions = await getTransactionsByChargeIds.run({
            chargeIds,
        }, this.dbProvider);
        transactions.map(t => {
            this.cache.set(`transaction-${t.id}`, t);
        });
        return chargeIds.map(id => transactions.filter(transaction => transaction.charge_id === id));
    }
    transactionsByChargeIDLoader = new DataLoader((keys) => this.batchTransactionsByChargeIDs(keys), {
        cacheKeyFn: id => `transactions-by-charge-${id}`,
        cacheMap: this.cache,
    });
    getTransactionsByFilters(params) {
        const isIDs = !!params?.IDs?.length;
        const isBusinessIDs = !!params?.businessIDs?.length;
        const isOwnerIDs = !!params?.ownerIDs?.length;
        const fullParams = {
            isIDs: isIDs ? 1 : 0,
            isBusinessIDs: isBusinessIDs ? 1 : 0,
            isOwnerIDs: isOwnerIDs ? 1 : 0,
            fromEventDate: null,
            toEventDate: null,
            fromDebitDate: null,
            toDebitDate: null,
            ...params,
            IDs: isIDs ? params.IDs : [null],
            businessIDs: isBusinessIDs ? params.businessIDs : [null],
            ownerIDs: isOwnerIDs ? params.ownerIDs : [null],
        };
        return getTransactionsByFilters.run(fullParams, this.dbProvider);
    }
    async getSimilarTransactions(params) {
        try {
            return getSimilarTransactions.run(params, this.dbProvider);
        }
        catch (error) {
            const message = 'Failed to fetch similar transactions';
            console.error(message, error);
            throw new Error(message);
        }
    }
    async replaceTransactionsChargeId(params) {
        if (params.replaceChargeID) {
            await this.invalidateTransactionByChargeID(params.replaceChargeID);
        }
        if (params.assertChargeID) {
            await this.invalidateTransactionByChargeID(params.assertChargeID);
        }
        return replaceTransactionsChargeId.run(params, this.dbProvider);
    }
    async updateTransaction(params) {
        if (params.transactionId) {
            await this.invalidateTransactionByID(params.transactionId);
        }
        return updateTransaction.run(params, this.dbProvider);
    }
    async invalidateTransactionByChargeID(chargeId) {
        try {
            const transactions = await getTransactionsByChargeIds.run({
                chargeIds: [chargeId],
            }, this.dbProvider);
            transactions.map(transaction => this.cache.delete(`transaction-${transaction.id}`));
            this.cache.delete(`transactions-by-charge-${chargeId}`);
        }
        catch (e) {
            console.error(`Error invalidating transaction by charge ID "${chargeId}":`, e);
        }
    }
    async invalidateTransactionByID(id) {
        try {
            const [transaction] = await getTransactionsByIds.run({
                transactionIds: [id],
            }, this.dbProvider);
            if (transaction) {
                this.cache.delete(`transactions-by-charge-${transaction.charge_id}`);
            }
            this.cache.delete(`transaction-${id}`);
        }
        catch (e) {
            console.error(`Error invalidating transaction by ID "${id}":`, e);
        }
    }
    clearCache() {
        this.cache.clear();
    }
};
TransactionsProvider = __decorate([
    Injectable({
        scope: Scope.Singleton,
        global: true,
    }),
    __metadata("design:paramtypes", [DBProvider])
], TransactionsProvider);
export { TransactionsProvider };
//# sourceMappingURL=transactions.provider.js.map