@accounter/server/dist/server/src/modules/deel/providers/deel-contracts.provider.js

The test suite is split into three Vitest projects for efficiency and isolation:

import { __decorate, __metadata } from "tslib";
import DataLoader from 'dataloader';
import { Injectable, Scope } from 'graphql-modules';
import { sql } from '@pgtyped/runtime';
import { getCacheInstance } from '../../../shared/helpers/index.js';
import { DBProvider } from '../../app-providers/db.provider.js';
const getEmployeeIDsByContractIds = sql `
  SELECT *
  FROM accounter_schema.deel_workers
  WHERE contract_id in $$contractIds;`;
const getEmployeeIdsByDocumentIds = sql `
  SELECT di.document_id, dw.business_id
  FROM accounter_schema.deel_invoices di
  LEFT JOIN accounter_schema.deel_workers dw
    ON di.contract_id = dw.contract_id
  WHERE di.document_id in $$documentIds;`;
const insertDeelContract = sql `
      INSERT INTO accounter_schema.deel_workers (
        contract_id,
        contractor_id,
        contractor_name,
        contract_start_date,
        business_id
      )
      VALUES (
        $contractId,
        $contractorId,
        $contractorName,
        $contractStartDate,
        $businessId
      )
      RETURNING *;`;
let DeelContractsProvider = class DeelContractsProvider {
    dbProvider;
    cache = getCacheInstance({
        stdTTL: 60 * 5,
    });
    constructor(dbProvider) {
        this.dbProvider = dbProvider;
    }
    async batchEmployeeIDsByContractIds(contractIds) {
        const contracts = await getEmployeeIDsByContractIds.run({ contractIds }, this.dbProvider);
        return contractIds.map(id => {
            const businessId = contracts.find(contract => contract.contract_id === id)?.business_id;
            if (!businessId) {
                throw new Error(`Missing businessId for Deel contract ID [${id}]`);
            }
            return businessId;
        });
    }
    getEmployeeIDByContractIdLoader = new DataLoader((contractIds) => this.batchEmployeeIDsByContractIds(contractIds), {
        cacheKeyFn: key => `worker-contract-${key}`,
        cacheMap: this.cache,
    });
    async batchEmployeesByContractIds(contractIds) {
        const contracts = await getEmployeeIDsByContractIds.run({ contractIds }, this.dbProvider);
        return contractIds.map(id => contracts.find(contract => contract.contract_id === id));
    }
    getEmployeeByContractIdLoader = new DataLoader((contractIds) => this.batchEmployeesByContractIds(contractIds), {
        cacheKeyFn: key => `worker-contract-full-${key}`,
        cacheMap: this.cache,
    });
    async batchEmployeeIdsByDocumentIds(documentIds) {
        const employeeMatches = await getEmployeeIdsByDocumentIds.run({ documentIds }, this.dbProvider);
        return documentIds.map(documentId => employeeMatches.find(match => match.document_id === documentId)?.business_id ?? null);
    }
    getEmployeeIdByDocumentIdLoader = new DataLoader((documentIds) => this.batchEmployeeIdsByDocumentIds(documentIds), {
        cacheKeyFn: key => `employee-by-document-${key}`,
        cacheMap: this.cache,
    });
    async insertDeelContract(params) {
        try {
            // invalidate cache
            return insertDeelContract.run(params, this.dbProvider);
        }
        catch (e) {
            const message = `Error inserting Deel contract [${params.contractId}]`;
            console.error(`${message}: ${e}`);
            throw new Error(message);
        }
    }
};
DeelContractsProvider = __decorate([
    Injectable({
        scope: Scope.Singleton,
        global: true,
    }),
    __metadata("design:paramtypes", [DBProvider])
], DeelContractsProvider);
export { DeelContractsProvider };
//# sourceMappingURL=deel-contracts.provider.js.map