task-stream/libs/api/tracker/infrastructure/src/lib/mongo/automations.repository.ts

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import {
  Automation,
  AutomationsRepository,
} from '@task-stream/api/tracker/application';
import { Model } from 'mongoose';
import {
  AutomationDoc,
  AutomationRunDoc,
  ReadModels,
  fromDoc,
} from './read-model.schemas';

const DUPLICATE_KEY = 11000;

@Injectable()
export class MongoAutomationsRepository extends AutomationsRepository {
  constructor(
    @InjectModel(ReadModels.Automation)
    private readonly automations: Model<AutomationDoc>,
    @InjectModel(ReadModels.AutomationRun)
    private readonly runs: Model<AutomationRunDoc>,
  ) {
    super();
  }

  async findByProject(projectId: string): Promise<Automation[]> {
    const docs = await this.automations
      .find({ projectId })
      .sort({ createdAt: 1 })
      .lean<AutomationDoc[]>();
    return docs.map((doc) => fromDoc(doc) as Automation);
  }

  async findActive(projectId: string): Promise<Automation[]> {
    const docs = await this.automations
      .find({ projectId, active: true })
      .lean<AutomationDoc[]>();
    return docs.map((doc) => fromDoc(doc) as Automation);
  }

  async findById(id: string): Promise<Automation | null> {
    const doc = await this.automations
      .findOne({ id: id })
      .lean<AutomationDoc>();
    return doc ? (fromDoc(doc) as Automation) : null;
  }

  async insert({ id, ...rest }: Automation): Promise<void> {
    await this.automations.create({ id, ...rest });
  }

  async update(
    id: string,
    changes: Partial<Pick<Automation, 'name' | 'active'>>,
  ): Promise<void> {
    if (Object.keys(changes).length)
      await this.automations.updateOne({ id }, { $set: changes });
  }

  async delete(id: string): Promise<void> {
    await this.automations.deleteOne({ id });
  }

  async claimRun(ruleId: string, eventKey: string): Promise<boolean> {
    try {
      await this.runs.create({ id: `${ruleId}:${eventKey}`, at: new Date() });
      return true;
    } catch (error) {
      if ((error as { code?: number }).code === DUPLICATE_KEY) return false;
      throw error;
    }
  }

  async recordRun(id: string, error: string | null): Promise<void> {
    await this.automations.updateOne(
      { id },
      {
        $inc: { runs: 1 },
        $set: { lastRunAt: new Date().toISOString(), lastError: error },
      },
    );
  }
}