Jorge Morais — Senior Full-Stack Developer at the intersection of AI and Industrial IoT · Remote, EU

// services/ReceiptWatcherService.ts
import chokidar from 'chokidar';
import { z } from 'zod';

const ReceiptSchema = z.object({
  receiptId: z.string(),
  terminalId: z.string(),
  departmentCode: z.string(),
  items: z.array(z.object({
    barcode: z.string(),
    description: z.string(),
    price: z.number(),
    quantity: z.number()
  })),
  total: z.number(),
  timestamp: z.date()
});

type Receipt = z.infer<typeof ReceiptSchema>;

export class ReceiptWatcherService {
  private watchers = new Map<string, chokidar.FSWatcher>();
  private processingQueue = new Map<string, Promise<void>>();

  async initializeTerminalWatchers(terminals: Terminal[]): Promise<void> {
    await Promise.all(terminals.map(terminal => this.watchTerminal(terminal)));
  }

  private async watchTerminal(terminal: Terminal): Promise<void> {
    const watcher = chokidar.watch(terminal.receiptPath, {
      persistent: true,
      ignoreInitial: true,
      awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
    });

    watcher.on('add', async (filePath) => {
      await this.handleNewReceipt(terminal, filePath);
    });

    this.watchers.set(terminal.id, watcher);
    logger.info(`Watching terminal ${terminal.id} at ${terminal.receiptPath}`);
  }

  private async handleNewReceipt(terminal: Terminal, filePath: string): Promise<void> {
    const receiptId = path.basename(filePath, '.json');
    const queueKey = `${terminal.id}:${receiptId}`;

    if (this.processingQueue.has(queueKey)) return;

    const processingPromise = this.processReceiptWithRetry(terminal, filePath, receiptId);
    this.processingQueue.set(queueKey, processingPromise);

    try {
      await processingPromise;
    } finally {
      this.processingQueue.delete(queueKey);
    }
  }

  private async processReceiptWithRetry(terminal: Terminal, filePath: string, receiptId: string, attempt = 0): Promise<void> {
    try {
      const rawData = await fs.promises.readFile(filePath, 'utf-8');
      const parsedData = JSON.parse(rawData);
      const receipt = ReceiptSchema.parse(parsedData);

      await this.syncToCentral(terminal, receipt);
      await this.generateFiscalFile(terminal, receipt);

      logger.info(`Successfully processed receipt ${receiptId} from terminal ${terminal.id}`);
    } catch (error) {
      if (attempt < 3 && this.isRetryable(error)) {
        const delay = Math.pow(2, attempt) * 1000;
        await sleep(delay);
        return this.processReceiptWithRetry(terminal, filePath, receiptId, attempt + 1);
      }
      logger.error(`Failed to process receipt ${receiptId}`, error);
      throw error;
    }
  }

  private async syncToCentral(terminal: Terminal, receipt: Receipt): Promise<void> {
    await AppDataSource.transaction(async (manager) => {
      for (const item of receipt.items) {
        await manager.getRepository(CentralTransaction).save({
          receiptId: receipt.receiptId,
          terminalId: terminal.id,
          departmentCode: terminal.departmentCode,
          barcode: item.barcode,
          description: item.description,
          price: item.price,
          quantity: item.quantity,
          timestamp: receipt.timestamp
        });
      }
    });
  }

  private isRetryable(error: any): boolean {
    return error.code === 'ENOENT' ||
           error.code === 'EBUSY' ||
           error instanceof z.ZodError === false;
  }
}

// services/FiscalFileGenerator.ts
export class FiscalFileGenerator {
  private config: FiscalConfig;

  async generateFiscalFile(terminal: Terminal, receipt: Receipt): Promise<void> {
    const dateFolder = format(new Date(), 'yyyyMMdd');
    const outputPath = path.join(this.config.baseOutputPath, dateFolder);
    await fs.promises.mkdir(outputPath, { recursive: true });

    const fileName = `scon${terminal.departmentCode}${receipt.receiptId}.dat`;
    const filePath = path.join(outputPath, fileName);

    const lines: string[] = receipt.items.map(item => {
      return this.config.fields.map(field => {
        const value = this.extractFieldValue(item, field, terminal);
        return this.formatField(value, field);
      }).join('');
    });

    await fs.promises.writeFile(filePath, lines.join('\r\n'));
  }

  private formatField(value: any, field: FieldConfig): string {
    let formatted = String(value);

    if (field.type === 'price') {
      formatted = String(Math.round(parseFloat(formatted) * 100));
    } else if (field.format === 'ddMMyy') {
      const date = new Date(formatted);
      formatted = format(date, 'ddMMyy');
    }

    return field.align === 'right'
      ? formatted.padStart(field.length, field.pad)
      : formatted.padEnd(field.length, field.pad).slice(0, field.length);
  }
}