metis-desk/modules/resources/src/api/module.ts

import { UniqueID } from "@repo/rdx-ddd";
import { Maybe, Result } from "@repo/rdx-utils";
import type { RequestHandler } from "express";
import type { Sequelize } from "sequelize";

import { ResourceUseCases } from "./application/resource.use-cases";
import { ResourceCatalogUseCases } from "./application/resource-catalog.use-cases";
import { ResourceInventoryService } from "./application/resource-inventory.service";
import { seedResourceCatalog } from "./domain/resource-catalog-seed";
import { registerResourceRoutes } from "./infrastructure/http/resource.routes";
import { registerResourceCatalogRoutes } from "./infrastructure/http/resource-catalog.routes";
import { migrateLegacyResources } from "./infrastructure/persistence/migrate-legacy-resources";
import { migrateSupportResources } from "./infrastructure/persistence/migrate-support-resources";
import { migrateInventory } from "./infrastructure/persistence/resource.model";
import {
  ResourceCatalogModel,
  migrateResourceCatalog,
} from "./infrastructure/persistence/resource-catalog.model";
import { ResourceCatalogPersistenceMapper } from "./infrastructure/persistence/resource-catalog-persistence.mapper";
import { ResourceDashboardReader } from "./infrastructure/persistence/resource-dashboard-reader";
import { enforceResourceConstraints } from "./infrastructure/persistence/resource-relational-schema";
import { migrateResourceRevisionSpecifications } from "./infrastructure/persistence/resource-revision-specifications";
import { SequelizeResourceRepository } from "./infrastructure/persistence/sequelize-resource.repository";
import { SequelizeResourceCatalogRepository } from "./infrastructure/persistence/sequelize-resource-catalog.repository";

export async function createResourceModule(database: Sequelize, authenticate: RequestHandler) {
  await migrateResourceCatalog(database);
  await ResourceCatalogModel.findOrCreate({
    where: { catalogKey: "global" },
    defaults: { id: UniqueID.generateNewID().toPrimitive(), catalogKey: "global" },
  });
  const repository = new SequelizeResourceCatalogRepository(
    database,
    new ResourceCatalogPersistenceMapper()
  );
  const seeded = await repository.update(Maybe.none(), (catalog) =>
    Result.ok(seedResourceCatalog(catalog))
  );

  if (!seeded.isSuccess) {
    throw new Error("No se pudo inicializar el catálogo de recursos.");
  }
  await migrateInventory(database);
  await migrateResourceRevisionSpecifications(database);
  await enforceResourceConstraints(database);
  await migrateSupportResources(database);
  const catalog = new ResourceCatalogUseCases(repository);
  const inventoryRepository = new SequelizeResourceRepository(database);
  const inventory = new ResourceUseCases(inventoryRepository);

  return {
    services: {
      inventory: new ResourceInventoryService(inventoryRepository),
      dashboard: new ResourceDashboardReader(database),
    },
    migrateLegacy: () => migrateLegacyResources(database),
    register: (app: Parameters<typeof registerResourceCatalogRoutes>[0]) => {
      registerResourceCatalogRoutes(app, catalog, authenticate);
      registerResourceRoutes(app, inventory, authenticate);
    },
  };
}