Backend Flow-Engine Slice — FLOW_REGISTRY Substrate Implementation Plan

import { describe, it, expect } from "bun:test";
import { DocumentType } from "../../generated/prisma/enums";

/**
 * Task 1 — the six additive supporting DocumentType values must exist on the
 * generated Prisma enum (they feed requiredDocs/checklistResetDocTypes typed
 * as DocumentType[]). Domisili is NOT new — it keeps using DOMISILI.
 */
describe("additive supporting DocumentType values", () => {
  const added = [
    "LAPORAN_KEUANGAN",
    "LAMPIRAN_LAPORAN_TAHUNAN",
    "SURAT_LIKUIDATOR",
    "LAPORAN_LIKUIDASI",
    "BUKTI_PENGUMUMAN",
    "SURAT_PERMOHONAN",
  ] as const;
  it("exposes every new value", () => {
    for (const v of added) {
      expect((DocumentType as Record<string, string>)[v]).toBe(v);
    }
  });
  it("keeps DOMISILI (domisili carrier — NOT replaced)", () => {
    expect(DocumentType.DOMISILI).toBe("DOMISILI");
  });
  it("does NOT introduce a SURAT_PERNYATAAN_DOMISILI enum value", () => {
    expect((DocumentType as Record<string, string>)["SURAT_PERNYATAAN_DOMISILI"]).toBeUndefined();
  });
});

  /// Laporan keuangan tahunan (RUPS Tahunan) — keyword-first + grounded-LLM classification.
  LAPORAN_KEUANGAN
  /// Carrier for the six Ps.66(2) letters b–g lampiran (store-only, manual board assignment).
  LAMPIRAN_LAPORAN_TAHUNAN
  /// Surat penunjukan likuidator (Pembubaran) — penunjukan shape ONLY.
  SURAT_LIKUIDATOR
  /// Laporan akhir / pertanggungjawaban likuidasi (Berakhirnya) — DISTINCT from SURAT_LIKUIDATOR.
  LAPORAN_LIKUIDASI
  /// Bukti pengumuman koran (Peleburan/Pembubaran/Berakhirnya) — keyword-suggest only, never auto-accepted.
  BUKTI_PENGUMUMAN
  /// Berakhirnya-status filing letter. DISTINCT from SURAT_PERMOHONAN_KORPORASI (the Perbaikan-korporasi letter).
  SURAT_PERMOHONAN

import { describe, it, expect } from "bun:test";
import { defineFlow, type FlowConfig, type Rule } from "../types";

describe("flow-engine types + defineFlow", () => {
  it("defineFlow is identity and preserves the config", () => {
    const rule: Rule<{ n: number }> = { code: "X", label: "x", run: () => [] };
    const cfg: FlowConfig<{ n: number }> = {
      type: "PERUBAHAN_PT",
      engine: "v2-generic",
      primaryAkta: { classifiedType: "AKTA_PERUBAHAN", missingError: "m", extractError: "e" },
      skipExtractionTypes: [],
      companyLookup: true,
      applyContactInfo: true,
      extraction: {},
      buildContext: async () => ({ n: 1 }),
      rules: [rule],
      requiredDocs: ["KTP"],
      sections: [],
      rematch: { checklistResetDocTypes: ["KTP"], standardPtMatchers: true },
      routeFamily: "perubahan",
      labels: { akta: "Akta", flow: "Flow" },
    };
    expect(defineFlow(cfg)).toBe(cfg);
    expect(cfg.failGate).toBeUndefined(); // defaults handled at the gate, not here
  });
});

import type { SubmissionType, DocumentType } from "../generated/prisma/enums";
import type { RuleResult } from "../services/cross-validator";
import type { ChangeTypeDetectionResult } from "../services/change-type-detector";
import type { Prisma } from "../generated/prisma/client";

export type { RuleResult };

/** Prisma interactive-transaction client (the arg $transaction(fn) passes). */
export type PrismaTxClient = Prisma.TransactionClient;

export type ValidationStatus = "PASS" | "WARNING" | "FAIL" | "SKIPPED";

export type RouteFamily =
  | "pendirian" | "perubahan" | "perbaikan" | "pp" | "peralihan-pp-pt" | "apostille"
  | "laporan-rups" | "peleburan" | "berakhirnya";

export interface Rule<Ctx> {
  code: string;
  label: string;
  severityFloor?: ValidationStatus; // clamp DOWN only
  async?: boolean;
  run(ctx: Ctx): RuleResult | RuleResult[] | Promise<RuleResult | RuleResult[]>;
}

export interface ProcessorHooks<Ctx> {
  mapChangeTypes?(ct: ChangeTypeDetectionResult): ChangeTypeDetectionResult;
  afterAktaExtraction?(a: { submissionId: string; aktaDocumentId: string; rawText: string }): Promise<void>;
  onFinalize?(tx: PrismaTxClient, submissionId: string): Promise<void>;
}

export interface RematchConfig {
  checklistResetDocTypes: DocumentType[];
  standardPtMatchers: boolean;
  preValidationSteps?: Array<(submissionId: string) => Promise<void>>;
}

export interface ExtractionPlan {
  overrideByClassifiedType?: Record<string, string>;
  focusedPasses?: Partial<Record<DocumentType, string>>;
}

export interface FlowConfig<Ctx = unknown> {
  type: SubmissionType;
  engine: "v2-generic";
  primaryAkta: { classifiedType: string; missingError: string; extractError: string } | null;
  skipExtractionTypes: string[];
  companyLookup: boolean | { allowedStatusTransaksi?: number[]; mode?: "single" | "multi-source" };
  applyContactInfo: boolean;
  extraction: ExtractionPlan;
  buildContext(submissionId: string): Promise<Ctx>;
  rules: Rule<Ctx>[];
  requiredDocs: DocumentType[];
  sections: { key: string; label: string; approvable: boolean; required: boolean }[];
  rematch: RematchConfig;
  hooks?: ProcessorHooks<Ctx>;
  routeFamily: RouteFamily;
  policy?: unknown; // INERT until the security slice
  failGate?: "on" | "off"; // default 'on' (enforced at the gate)
  customProcess?(id: string, cfg: FlowConfig<Ctx>): Promise<void>;
  labels: { akta: string; flow: string };
}

export function defineFlow<Ctx>(cfg: FlowConfig<Ctx>): FlowConfig<Ctx> {
  return cfg;
}

import { describe, it, expect } from "bun:test";
import { SubmissionType } from "../../generated/prisma/enums";
import { FLOW_REGISTRY, flowFor, typesForRouteFamily } from "../registry";

describe("FLOW_REGISTRY totality", () => {
  it("has an entry for every SubmissionType with a valid engine", () => {
    for (const t of Object.values(SubmissionType)) {
      const entry = FLOW_REGISTRY[t];
      expect(entry, `missing registry entry for ${t}`).toBeDefined();
      expect(["v1-fork", "v2-generic"]).toContain(entry.engine);
      expect(entry.type).toBe(t);
    }
  });
  it("ships every existing type as a v1-fork stub (no v2 entries yet)", () => {
    for (const t of Object.values(SubmissionType)) {
      expect(FLOW_REGISTRY[t].engine).toBe("v1-fork");
    }
  });
  it("flowFor resolves the same entry", () => {
    expect(flowFor("PERUBAHAN_PT")).toBe(FLOW_REGISTRY.PERUBAHAN_PT);
  });
  it("typesForRouteFamily returns [] while no v2 flows are registered", () => {
    expect(typesForRouteFamily("perubahan")).toEqual([]);
  });
});

import type { SubmissionType } from "../generated/prisma/enums";
import type { FlowConfig, RouteFamily } from "./types";

/** Migration-period union: v1 forks carry only {engine,type}; v2 carries a full FlowConfig. */
export type FlowEntry = { engine: "v1-fork"; type: SubmissionType } | FlowConfig<any>;

/**
 * TOTAL registry — Record<SubmissionType, FlowEntry>. Adding a SubmissionType to
 * the Prisma enum makes this a missing-key compile error: the adoption forcing
 * mechanism. Each new flow spec replaces its future stub with a real defineFlow(...).
 */
export const FLOW_REGISTRY: Record<SubmissionType, FlowEntry> = {
  PENDIRIAN_PT:       { engine: "v1-fork", type: "PENDIRIAN_PT" },
  PERUBAHAN_PT:       { engine: "v1-fork", type: "PERUBAHAN_PT" },
  AKUISISI_PT:        { engine: "v1-fork", type: "AKUISISI_PT" },
  PERBAIKAN_DATA_PT:  { engine: "v1-fork", type: "PERBAIKAN_DATA_PT" },
  PENDIRIAN_PP:       { engine: "v1-fork", type: "PENDIRIAN_PP" },
  PERUBAHAN_PP:       { engine: "v1-fork", type: "PERUBAHAN_PP" },
  PERBAIKAN_DATA_PP:  { engine: "v1-fork", type: "PERBAIKAN_DATA_PP" },
  PEMBUBARAN_PP:      { engine: "v1-fork", type: "PEMBUBARAN_PP" },
  PERALIHAN_PP_KE_PT: { engine: "v1-fork", type: "PERALIHAN_PP_KE_PT" },
  APOSTILLE:          { engine: "v1-fork", type: "APOSTILLE" },
};

export const flowFor = (t: SubmissionType): FlowEntry => FLOW_REGISTRY[t];

/** Route-family sets derive from the registry so route files stop hardcoding type lists. */
export function typesForRouteFamily(family: RouteFamily): SubmissionType[] {
  const out: SubmissionType[] = [];
  for (const entry of Object.values(FLOW_REGISTRY)) {
    if (entry.engine === "v2-generic" && entry.routeFamily === family) out.push(entry.type);
  }
  return out;
}

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { buildPtAktaContext } from "../context/pt-akta-context";

/**
 * Task 4 — the lifted context builder assembles a ValidationInput parameterized
 * by the akta classifiedType + optional tanggalKoran field key. We assert the
 * two parameterized seams (akta selection + tanggalKoran) resolve correctly on a
 * minimal seeded submission; the full field-by-field fidelity is proven by the
 * parity oracle (Task 11) against the fork.
 */
describe("buildPtAktaContext", () => {
  const ids: string[] = [];
  const docIds: string[] = [];
  afterAll(async () => {
    for (const id of ids) await db.submission.deleteMany({ where: { id } });
    for (const d of docIds) await db.document.deleteMany({ where: { id: d } });
  });

  it("selects the akta by classifiedType and reads tanggalKoran from the given key", async () => {
    const doc = await db.document.create({
      data: { filename: "a.pdf", originalName: "a.pdf", fileSize: 0, filePath: "/tmp/a.pdf", documentType: "AKTA", status: "AI_EXTRACTION", rawText: "" },
    });
    docIds.push(doc.id);
    await db.extractedField.createMany({
      data: [
        { documentId: doc.id, fieldKey: "nama_perseroan", value: "PT UJI" },
        { documentId: doc.id, fieldKey: "tanggal_koran_akuisisi", value: "2020-01-01" },
      ],
    });
    const sub = await db.submission.create({ data: { type: "AKUISISI_PT", status: "VALIDATING" } });
    ids.push(sub.id);
    await db.submissionDocument.create({
      data: { submissionId: sub.id, documentId: doc.id, classifiedType: "AKTA_AKUISISI", processingOrder: 0, extractionStatus: "DONE" },
    });

    const ctx = await buildPtAktaContext(sub.id, {
      aktaClassifiedType: "AKTA_AKUISISI",
      tanggalKoranFieldKey: "tanggal_koran_akuisisi",
    });
    expect(ctx.input.aktaNamaPerseroan).toBe("PT UJI");
    expect(ctx.input.tanggalKoran).toBe("2020-01-01");
    expect(Array.isArray(ctx.rupsQuorum.pemegangSaham)).toBe(true);
  });

  it("returns null tanggalKoran when no field key is given (perubahan shape)", async () => {
    const doc = await db.document.create({
      data: { filename: "b.pdf", originalName: "b.pdf", fileSize: 0, filePath: "/tmp/b.pdf", documentType: "AKTA", status: "AI_EXTRACTION", rawText: "" },
    });
    docIds.push(doc.id);
    await db.extractedField.create({ data: { documentId: doc.id, fieldKey: "nama_perseroan", value: "PT DUA" } });
    const sub = await db.submission.create({ data: { type: "PERUBAHAN_PT", status: "VALIDATING" } });
    ids.push(sub.id);
    await db.submissionDocument.create({
      data: { submissionId: sub.id, documentId: doc.id, classifiedType: "AKTA_PERUBAHAN", processingOrder: 0, extractionStatus: "DONE" },
    });
    const ctx = await buildPtAktaContext(sub.id, { aktaClassifiedType: "AKTA_PERUBAHAN" });
    expect(ctx.input.aktaNamaPerseroan).toBe("PT DUA");
    expect(ctx.input.tanggalKoran).toBeNull();
  });
});

  const hasBaRupsDoc = submission.documents.some((d) => d.classifiedType === "BERITA_ACARA_RUPS");
  return {
    input,
    rupsQuorum: {
      pemegangSaham: (aktaDoc?.aktaPemegangSaham ?? []).map((ps) => ({
        persentase: ps.persentase,
        kehadiranRups: ps.kehadiranRups,
      })),
      hasBaRupsDoc,
    },
    aktaFields: aktaFields.map((f) => ({ fieldKey: f.fieldKey, value: f.value })),
  };

import { describe, it, expect } from "bun:test";
import { PT_AKTA_RULE_SET, pickRules } from "../rules/pt-akta/index";
import { rupsQuorumRule } from "../rules/pt-akta/rups-quorum";
import { akuisisiKoranRule } from "../rules/akuisisi/koran-window";
import type { PtAktaCtx } from "../context/pt-akta-context";

const EXPECTED_CODES = [
  "NIK_KTP_AKTA","NAMA_NPWP_KTP","MODAL_BUKTI_SETOR","PEMEGANG_SAHAM_BUKTI_SETOR","SHARES_SUM_CONSISTENCY",
  "MODAL_HIERARCHY","NOMINAL_RECONCILE","KTP_COMPLETENESS","NPWP_COMPLETENESS","DOMISILI_NAMA",
  "NAMA_PT_CONSISTENCY","PS_TOTAL_100","CONTACT_INFO_COMPLETE","OLD_DATA_CONSISTENCY","PERUBAHAN_MODAL",
  "DATA_ACTUALLY_CHANGED","SHARES_TRANSFER_BALANCE","SHARES_TOTAL_LEMBAR","REQUIRED_SUPPORTING_DOCS",
  "AKTA_DATE_WINDOW","PERSEROAN_STATE","NPWP_PERSEROAN_FUZZY","NOTARIS_TERAKHIR","JENIS_SELECTION_NONEMPTY",
  "JENIS_DESELECT_REASONS_COMPLETE","UPLOADED_DOC_UNUSED","CONTRADICTORY_JENIS","PEMEGANG_SAHAM_CONTACT",
  "PASSPORT_AKTA","PP29_MODAL","KBLI_VALID","PERUBAHAN_KBLI",
];

describe("PT_AKTA_RULE_SET", () => {
  it("has exactly the 32 shared rules, each with code+label+run", () => {
    expect(PT_AKTA_RULE_SET.map((r) => r.code).sort()).toEqual([...EXPECTED_CODES].sort());
    for (const r of PT_AKTA_RULE_SET) {
      expect(r.code.length).toBeGreaterThan(0);
      expect(r.label.length).toBeGreaterThan(0);
      expect(typeof r.run).toBe("function");
    }
  });
  it("marks exactly the 3 SABH-hitting rules as async", () => {
    const asyncCodes = PT_AKTA_RULE_SET.filter((r) => r.async).map((r) => r.code).sort();
    expect(asyncCodes).toEqual(["KBLI_VALID", "PERUBAHAN_KBLI", "PP29_MODAL"].sort());
  });
  it("pickRules filters by code preserving order and dropping unknowns", () => {
    const picked = pickRules(PT_AKTA_RULE_SET, ["NIK_KTP_AKTA", "NOPE", "PASSPORT_AKTA"]);
    expect(picked.map((r) => r.code)).toEqual(["NIK_KTP_AKTA", "PASSPORT_AKTA"]);
  });
});

describe("rupsQuorumRule wrapper", () => {
  it("adapts {code,status,message} to a RuleResult with the RUPS label", () => {
    const ctx = { rupsQuorum: { pemegangSaham: [], hasBaRupsDoc: false } } as unknown as PtAktaCtx;
    const rule = rupsQuorumRule();
    expect(rule.code).toBe("RUPS_ATTENDANCE_QUORUM");
    const out = rule.run(ctx) as { ruleCode: string; ruleLabel: string; status: string };
    expect(out.ruleCode).toBe("RUPS_ATTENDANCE_QUORUM");
    expect(out.ruleLabel).toBe("Kuorum Kehadiran RUPS");
    expect(out.status).toBe("SKIPPED"); // no BA RUPS doc
  });
  it("threshold param clamps a >1/2-but-<3/4 attendance to WARNING", () => {
    const ctx = {
      rupsQuorum: {
        pemegangSaham: [{ persentase: 60, kehadiranRups: true }, { persentase: 40, kehadiranRups: false }],
        hasBaRupsDoc: true,
      },
    } as unknown as PtAktaCtx;
    const base = rupsQuorumRule().run(ctx) as { status: string };
    const strict = rupsQuorumRule({ quorumThreshold: 3 / 4 }).run(ctx) as { status: string };
    expect(base.status).toBe("PASS");     // 60% > 50%
    expect(strict.status).toBe("WARNING"); // 60% < 75%
  });
});

describe("akuisisiKoranRule wrapper", () => {
  it("wraps validateAkuisisiKoranWindow with severityFloor WARNING", () => {
    expect(akuisisiKoranRule.code).toBe("AKUISISI_KORAN_WINDOW");
    expect(akuisisiKoranRule.severityFloor).toBe("WARNING");
    const ctx = {
      input: { tanggalKoran: null },
      aktaFields: [{ fieldKey: "tanggal_rups", value: null }],
    } as unknown as PtAktaCtx;
    const out = akuisisiKoranRule.run(ctx) as { ruleCode: string };
    expect(out.ruleCode).toBe("AKUISISI_KORAN_WINDOW");
  });
});

import {
  validateNikKtpAkta, validateNamaNpwpKtp, validateModalBuktiSetor, validatePemegangSahamBuktiSetor,
  validateSharesSumConsistency, validateModalHierarchy, validateNominalReconcile, validateKtpCompleteness,
  validateNpwpCompleteness, validateDomisiliNama, validateNamaPerseroan, validatePemegangSahamTotal,
  validateContactInfoComplete, validateOldDataConsistency, validatePerubahanModal, validateDataActuallyChanged,
  validateSharesTransferBalance, validateSharesTotalLembar, validateRequiredSupportingDocs, validateAktaDateWindow,
  validatePerseroanState, validateNpwpPerseroanFuzzyMatch, validateNotarisTerakhir, validateJenisSelectionNonempty,
  validateJenisDeselectReasonsComplete, validateUploadedDocUnused, validateContradictoryJenis,
  validatePemegangSahamContact, validatePassportAkta, validatePp29Modal, validateKbli, validatePerubahanKbli,
} from "../../../services/cross-validator";
import type { Rule } from "../../types";
import type { PtAktaCtx } from "../../context/pt-akta-context";

/** Wrappers ONLY — legal logic + severities stay in cross-validator.ts. Order mirrors runAllValidations. */
export const PT_AKTA_RULE_SET: Rule<PtAktaCtx>[] = [
  { code: "NIK_KTP_AKTA", label: "NIK KTP sesuai dengan Akta", run: (c) => validateNikKtpAkta(c.input) },
  { code: "NAMA_NPWP_KTP", label: "Nama NPWP vs KTP", run: (c) => validateNamaNpwpKtp(c.input) },
  { code: "MODAL_BUKTI_SETOR", label: "Modal vs Bukti Setor", run: (c) => validateModalBuktiSetor(c.input) },
  { code: "PEMEGANG_SAHAM_BUKTI_SETOR", label: "Pemegang Saham vs Bukti Setor", run: (c) => validatePemegangSahamBuktiSetor(c.input) },
  { code: "SHARES_SUM_CONSISTENCY", label: "Konsistensi Jumlah Saham", run: (c) => validateSharesSumConsistency(c.input) },
  { code: "MODAL_HIERARCHY", label: "Hierarki Modal", run: (c) => validateModalHierarchy(c.input) },
  { code: "NOMINAL_RECONCILE", label: "Rekonsiliasi Nominal", run: (c) => validateNominalReconcile(c.input) },
  { code: "KTP_COMPLETENESS", label: "Kelengkapan KTP", run: (c) => validateKtpCompleteness(c.input) },
  { code: "NPWP_COMPLETENESS", label: "Kelengkapan NPWP", run: (c) => validateNpwpCompleteness(c.input) },
  { code: "DOMISILI_NAMA", label: "Nama Domisili", run: (c) => validateDomisiliNama(c.input) },
  { code: "NAMA_PT_CONSISTENCY", label: "Konsistensi Nama PT", run: (c) => validateNamaPerseroan(c.input) },
  { code: "PS_TOTAL_100", label: "Total Persentase Pemegang Saham", run: (c) => validatePemegangSahamTotal(c.input) },
  { code: "CONTACT_INFO_COMPLETE", label: "Kelengkapan Data Kontak", run: (c) => validateContactInfoComplete(c.input) },
  { code: "OLD_DATA_CONSISTENCY", label: "Konsistensi Data Lama", run: (c) => validateOldDataConsistency(c.input) },
  { code: "PERUBAHAN_MODAL", label: "Perubahan Modal", run: (c) => validatePerubahanModal(c.input) },
  { code: "DATA_ACTUALLY_CHANGED", label: "Data Berubah", run: (c) => validateDataActuallyChanged(c.input) },
  { code: "SHARES_TRANSFER_BALANCE", label: "Keseimbangan Peralihan Saham", run: (c) => validateSharesTransferBalance(c.input) },
  { code: "SHARES_TOTAL_LEMBAR", label: "Total Lembar Saham", run: (c) => validateSharesTotalLembar(c.input) },
  { code: "REQUIRED_SUPPORTING_DOCS", label: "Dokumen Pendukung Wajib", run: (c) => validateRequiredSupportingDocs(c.input) },
  { code: "AKTA_DATE_WINDOW", label: "Tanggal Akta dalam Jangka", run: (c) => validateAktaDateWindow(c.input) },
  { code: "PERSEROAN_STATE", label: "Status PT Aktif di SABH", run: (c) => validatePerseroanState(c.input) },
  { code: "NPWP_PERSEROAN_FUZZY", label: "NPWP Perseroan (Fuzzy)", run: (c) => validateNpwpPerseroanFuzzyMatch(c.input) },
  { code: "NOTARIS_TERAKHIR", label: "Notaris Terakhir", run: (c) => validateNotarisTerakhir(c.input) },
  { code: "JENIS_SELECTION_NONEMPTY", label: "Jenis Perubahan Tidak Kosong", run: (c) => validateJenisSelectionNonempty(c.input) },
  { code: "JENIS_DESELECT_REASONS_COMPLETE", label: "Alasan Deseleksi Lengkap", run: (c) => validateJenisDeselectReasonsComplete(c.input) },
  { code: "UPLOADED_DOC_UNUSED", label: "Dokumen Terunggah Tidak Terpakai", run: (c) => validateUploadedDocUnused(c.input) },
  { code: "CONTRADICTORY_JENIS", label: "Jenis Bertentangan", run: (c) => validateContradictoryJenis(c.input) },
  { code: "PEMEGANG_SAHAM_CONTACT", label: "Kontak Pemegang Saham", run: (c) => validatePemegangSahamContact(c.input) },
  { code: "PASSPORT_AKTA", label: "Paspor sesuai Akta", run: (c) => validatePassportAkta(c.input) },
  { code: "PP29_MODAL", label: "PP 29/2016 Modal", async: true, run: (c) => validatePp29Modal(c.input) },
  { code: "KBLI_VALID", label: "KBLI Valid", async: true, run: (c) => validateKbli(c.input) },
  { code: "PERUBAHAN_KBLI", label: "KBLI Perubahan", async: true, run: (c) => validatePerubahanKbli(c.input) },
];

/** Typed filter — the tuned matrix is `pickRules(PT_AKTA_RULE_SET, FLOW_CODES)` + flow rules. */
export function pickRules(set: Rule<PtAktaCtx>[], codes: readonly string[]): Rule<PtAktaCtx>[] {
  const wanted = new Set(codes);
  return set.filter((r) => wanted.has(r.code));
}

import { validateRupsAttendanceQuorum } from "../../../services/cross-validator";
import type { Rule, RuleResult } from "../../types";
import type { PtAktaCtx } from "../../context/pt-akta-context";

/**
 * Wraps validateRupsAttendanceQuorum (body returns {code,status,message}) into a
 * RuleResult with ruleLabel "Kuorum Kehadiran RUPS" — bit-for-bit what both forks
 * append today. Default legal quorum is >1/2 (UUPT Ps.86(1)); Pembubaran passes 3/4
 * (Ps.89(1)). When a threshold is given we recompute the tier from the same present/
 * total percentages the body exposes in its message — the body itself is unchanged.
 */
export function rupsQuorumRule(opts?: { quorumThreshold?: number }): Rule<PtAktaCtx> {
  const threshold = opts?.quorumThreshold ?? 0.5;
  return {
    code: "RUPS_ATTENDANCE_QUORUM",
    label: "Kuorum Kehadiran RUPS",
    run: (c): RuleResult => {
      const raw = validateRupsAttendanceQuorum(c.rupsQuorum);
      let status = raw.status as RuleResult["status"];
      let message = raw.message;
      // Only re-tier when a stricter threshold is requested AND the body evaluated a real quorum.
      if (raw.status !== "SKIPPED" && threshold > 0.5) {
        const total = c.rupsQuorum.pemegangSaham.reduce((s, p) => s + (p.persentase ?? 0), 0);
        const present = c.rupsQuorum.pemegangSaham
          .filter((p) => p.kehadiranRups === true)
          .reduce((s, p) => s + (p.persentase ?? 0), 0);
        if (total > 0) {
          const ratio = present / total;
          if (ratio <= threshold) {
            status = "WARNING";
            const pct = (threshold * 100).toFixed(0);
            message = `Kehadiran RUPS ${present.toFixed(2)}% dari total ${total.toFixed(2)}% (kuorum legal >${pct}%)`;
          }
        }
      }
      return { ruleCode: raw.code, ruleLabel: "Kuorum Kehadiran RUPS", status, message };
    },
  };
}

import { validateAkuisisiKoranWindow } from "../../../services/cross-validator";
import type { Rule } from "../../types";
import type { PtAktaCtx } from "../../context/pt-akta-context";

/**
 * AKUISISI_KORAN_WINDOW ≤ WARNING — the body already never FAILs (UUPT Ps.127(8)
 * exempts direct-from-shareholder acquisitions). The severityFloor is
 * belt-and-braces documentation-in-types. tanggalRups is read from aktaFields.
 */
export const akuisisiKoranRule: Rule<PtAktaCtx> = {
  code: "AKUISISI_KORAN_WINDOW",
  label: "Pengumuman Koran ≥30 Hari sebelum RUPS",
  severityFloor: "WARNING",
  run: (c) => {
    const tanggalRups = c.aktaFields.find((f) => f.fieldKey === "tanggal_rups")?.value ?? null;
    return validateAkuisisiKoranWindow({ tanggalKoran: c.input.tanggalKoran, tanggalRups });
  },
};

import { describe, it, expect } from "bun:test";
import { runValidations } from "../validation-runner";
import type { Rule, RuleResult } from "../types";

type Ctx = { v: number };
const mk = (code: string, status: RuleResult["status"]): RuleResult => ({ ruleCode: code, ruleLabel: code, status, message: "" });

describe("runValidations", () => {
  it("runs async rules in parallel (wall clock ≈ max, not sum)", async () => {
    const slow = (code: string): Rule<Ctx> => ({
      code, label: code, async: true,
      run: async () => { await new Promise((r) => setTimeout(r, 80)); return mk(code, "PASS"); },
    });
    const start = Date.now();
    const out = await runValidations({ rules: [slow("A"), slow("B"), slow("C")] }, { v: 1 });
    const elapsed = Date.now() - start;
    expect(out.map((r) => r.ruleCode).sort()).toEqual(["A", "B", "C"]);
    expect(elapsed).toBeLessThan(200); // ~80ms parallel, not ~240ms serial
  });
  it("flattens RuleResult[] returns", async () => {
    const multi: Rule<Ctx> = { code: "M", label: "M", run: () => [mk("M1", "PASS"), mk("M2", "FAIL")] };
    const out = await runValidations({ rules: [multi] }, { v: 1 });
    expect(out.map((r) => r.ruleCode)).toEqual(["M1", "M2"]);
  });
  it("severityFloor clamps FAIL down to the floor; never raises", async () => {
    const failing: Rule<Ctx> = { code: "F", label: "F", severityFloor: "WARNING", run: () => mk("F", "FAIL") };
    const passing: Rule<Ctx> = { code: "P", label: "P", severityFloor: "WARNING", run: () => mk("P", "PASS") };
    const out = await runValidations({ rules: [failing, passing] }, { v: 1 });
    expect(out.find((r) => r.ruleCode === "F")?.status).toBe("WARNING"); // clamped down
    expect(out.find((r) => r.ruleCode === "P")?.status).toBe("PASS");    // never raised
  });
});

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { persistValidationResults } from "../validation-runner";
import type { RuleResult } from "../types";

const r = (code: string, status: RuleResult["status"], msg: string): RuleResult => ({ ruleCode: code, ruleLabel: code, status, message: msg });

describe("persistValidationResults", () => {
  const ids: string[] = [];
  afterAll(async () => {
    for (const id of ids) { await db.validationResult.deleteMany({ where: { submissionId: id } }); await db.submission.deleteMany({ where: { id } }); }
  });
  it("preserves overridden+reason on re-persist; updates status/message; notIn-deletes stale", async () => {
    const sub = await db.submission.create({ data: { type: "PERUBAHAN_PT", status: "READY" } });
    ids.push(sub.id);
    await db.validationResult.create({ data: { submissionId: sub.id, ruleCode: "KEEP", ruleLabel: "KEEP", status: "FAIL", message: "old", overridden: true, overrideReason: "notaris" } });
    await db.validationResult.create({ data: { submissionId: sub.id, ruleCode: "STALE", ruleLabel: "STALE", status: "FAIL", message: "x" } });
    await persistValidationResults(sub.id, [r("KEEP", "FAIL", "new"), r("FRESH", "PASS", "ok")]);
    const keep = await db.validationResult.findUnique({ where: { submissionId_ruleCode: { submissionId: sub.id, ruleCode: "KEEP" } } });
    const stale = await db.validationResult.findUnique({ where: { submissionId_ruleCode: { submissionId: sub.id, ruleCode: "STALE" } } });
    const fresh = await db.validationResult.findUnique({ where: { submissionId_ruleCode: { submissionId: sub.id, ruleCode: "FRESH" } } });
    expect(keep?.overridden).toBe(true);
    expect(keep?.overrideReason).toBe("notaris");
    expect(keep?.message).toBe("new");
    expect(stale).toBeNull();
    expect(fresh).not.toBeNull();
  });
  it("blanketDelete:true removes ALL rows first (fork parity path)", async () => {
    const sub = await db.submission.create({ data: { type: "PERUBAHAN_PT", status: "READY" } });
    ids.push(sub.id);
    await db.validationResult.create({ data: { submissionId: sub.id, ruleCode: "OVR", ruleLabel: "OVR", status: "FAIL", message: "x", overridden: true, overrideReason: "gone" } });
    await persistValidationResults(sub.id, [r("OVR", "FAIL", "y")], { blanketDelete: true });
    const row = await db.validationResult.findUnique({ where: { submissionId_ruleCode: { submissionId: sub.id, ruleCode: "OVR" } } });
    expect(row?.overridden).toBe(false); // blanket-deleted then re-created without the override
  });
});

import { db } from "../lib/db";
import { Prisma } from "../generated/prisma/client";
import type { Rule, RuleResult, ValidationStatus } from "./types";

const SEVERITY_ORDER: Record<ValidationStatus, number> = { PASS: 0, WARNING: 1, FAIL: 2, SKIPPED: -1 };

/** Clamp DOWN only (never raise); SKIPPED passes through unchanged. */
function applyFloor(status: ValidationStatus, floor?: ValidationStatus): ValidationStatus {
  if (!floor || status === "SKIPPED" || floor === "SKIPPED") return status;
  return SEVERITY_ORDER[status] > SEVERITY_ORDER[floor] ? floor : status;
}

/**
 * Partition rules by async: sync rules run sequentially (pure/instant), async
 * rules via Promise.all (SABH round-trips) — preserving today's latency profile.
 * Flattens RuleResult[] returns; applies severityFloor; dev-mode drift assertion.
 */
export async function runValidations<Ctx>(cfg: { rules: Rule<Ctx>[] }, ctx: Ctx): Promise<RuleResult[]> {
  const out: RuleResult[] = [];
  const collect = (rule: Rule<Ctx>, res: RuleResult | RuleResult[]) => {
    const arr = Array.isArray(res) ? res : [res];
    for (const rr of arr) {
      if (process.env.NODE_ENV !== "production" && !Array.isArray(res) && rr.ruleCode !== rule.code) {
        console.warn(`[flow-engine] rule "${rule.code}" emitted ruleCode "${rr.ruleCode}" — wrapper drift`);
      }
      out.push({ ...rr, status: applyFloor(rr.status as ValidationStatus, rule.severityFloor) });
    }
  };
  const asyncRules = cfg.rules.filter((r) => r.async);
  const syncRules = cfg.rules.filter((r) => !r.async);
  for (const rule of syncRules) collect(rule, await rule.run(ctx));
  const asyncResults = await Promise.all(asyncRules.map((r) => Promise.resolve(r.run(ctx))));
  asyncRules.forEach((rule, i) => collect(rule, asyncResults[i]!));
  return out;
}

/**
 * ONE $transaction: delete stale (notIn) — or blanket-delete when opted in — then
 * upsert. The update branch sets ONLY {status,message,details} so overridden/
 * overrideReason survive re-validation. Default blanketDelete:false (v2 greenfield).
 */
export async function persistValidationResults(
  submissionId: string,
  results: RuleResult[],
  opts?: { blanketDelete?: boolean },
): Promise<void> {
  const validCodes = results.map((r) => r.ruleCode);
  await db.$transaction([
    opts?.blanketDelete
      ? db.validationResult.deleteMany({ where: { submissionId } })
      : db.validationResult.deleteMany({ where: { submissionId, ruleCode: { notIn: validCodes } } }),
    ...results.map((res) =>
      db.validationResult.upsert({
        where: { submissionId_ruleCode: { submissionId, ruleCode: res.ruleCode } },
        create: {
          submissionId, ruleCode: res.ruleCode, ruleLabel: res.ruleLabel,
          status: res.status, message: res.message,
          details: (res.details as unknown as Prisma.InputJsonValue) ?? undefined,
        },
        update: {
          status: res.status, message: res.message,
          details: (res.details as unknown as Prisma.InputJsonValue) ?? undefined,
        },
      }),
    ),
  ]);
}