@tailor-platform/erp-kit 0.2.2 → 0.4.0

package/src/modules/audit/command/registerAuditableEntity.test.ts

@@ -0,0 +1,268 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { type CommandContext, InsufficientPermissionError } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidEntityNameError,
+  DuplicateEntityNameError,
+  InvalidEntityScopeError,
+  InvalidAuditableFieldsError,
+} from "../lib/errors.generated";
+import { companyBoundEntity, globalEntity } from "../testing/fixtures";
+import { run } from "./registerAuditableEntity";
+import { registerAuditableEntity } from "./registerAuditableEntity.generated";
+
+const ctx: CommandContext = {
+  actorId: "test-actor",
+  permissions: ["audit:registerAuditableEntity"],
+};
+
+describe("registerAuditableEntity", () => {
+  it("registers entity with COMPANY_BOUND scope", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // no duplicate
+    spies.insert.mockReturnValue(companyBoundEntity);
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: ["amount", "status", "customerId"],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.auditableEntity.entityName).toBe("SalesOrder");
+      expect(result.value.auditableEntity.entityScope).toBe("COMPANY_BOUND");
+    }
+  });
+
+  it("registers entity with GLOBAL scope", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // no duplicate
+    spies.insert.mockReturnValue(globalEntity);
+
+    const result = await run(
+      db,
+      {
+        entityName: "User",
+        entityScope: "GLOBAL",
+        auditableFields: ["email", "role", "isActive"],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.auditableEntity.entityName).toBe("User");
+      expect(result.value.auditableEntity.entityScope).toBe("GLOBAL");
+    }
+  });
+
+  it("rejects registration with empty entityName", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        entityName: "",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: ["amount"],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidEntityNameError);
+    }
+  });
+
+  it("rejects registration with duplicate entityName", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(companyBoundEntity); // existing entity found
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: ["amount"],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateEntityNameError);
+    }
+  });
+
+  it("rejects registration with invalid entityScope", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "INVALID_SCOPE",
+        auditableFields: ["amount"],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidEntityScopeError);
+    }
+  });
+
+  it("rejects registration with empty auditableFields", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: [],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAuditableFieldsError);
+    }
+  });
+
+  it("rejects registration with binary field type in auditableFields", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: [
+          { fieldName: "amount", fieldType: "scalar" },
+          { fieldName: "blobData", fieldType: "binary" },
+        ],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAuditableFieldsError);
+    }
+  });
+
+  it("rejects registration with computed field type in auditableFields", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: [
+          { fieldName: "amount", fieldType: "scalar" },
+          { fieldName: "total", fieldType: "computed" },
+        ],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAuditableFieldsError);
+    }
+  });
+
+  it("accepts mixed string and object field definitions in auditableFields", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // no duplicate
+    spies.insert.mockReturnValue(companyBoundEntity);
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: ["amount", { fieldName: "status", fieldType: "scalar" }],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+  });
+
+  it("rejects registration with empty field name in auditableFields", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: ["amount", "", "status"],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAuditableFieldsError);
+    }
+  });
+
+  it("rejects registration with unknown field type in auditableFields", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: [
+          { fieldName: "amount", fieldType: "scalar" },
+          { fieldName: "custom", fieldType: "nonsense" as never },
+        ],
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidAuditableFieldsError);
+    }
+  });
+
+  it("rejects caller without registerAuditableEntity permission", async () => {
+    const { db } = createMockDb<Transaction>();
+    const command = registerAuditableEntity();
+    const noPermCtx: CommandContext = {
+      actorId: "test-actor",
+      permissions: [],
+    };
+
+    const result = await command(
+      db,
+      {
+        entityName: "SalesOrder",
+        entityScope: "COMPANY_BOUND",
+        auditableFields: ["amount"],
+      },
+      noPermCtx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InsufficientPermissionError);
+    }
+  });
+});

package/src/modules/audit/command/registerAuditableEntity.ts

@@ -0,0 +1,94 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidEntityNameError,
+  DuplicateEntityNameError,
+  InvalidEntityScopeError,
+  InvalidAuditableFieldsError,
+} from "../lib/errors.generated";
+
+interface AuditableFieldDef {
+  fieldName: string;
+  fieldType?: "scalar" | "richtext" | "array" | "relation" | "file" | "binary" | "computed";
+}
+
+export interface RegisterAuditableEntityInput {
+  entityName: string;
+  entityScope: string;
+  auditableFields: (string | AuditableFieldDef)[];
+}
+
+const VALID_SCOPES = ["COMPANY_BOUND", "GLOBAL"] as const;
+
+/**
+ * Function: registerAuditableEntity
+ *
+ * Registers a new auditable entity type in the system with a given scope and
+ * set of auditable fields. The entity name must be unique.
+ */
+export async function run(
+  db: Transaction,
+  input: RegisterAuditableEntityInput,
+  _ctx: CommandContext,
+) {
+  const { entityName, entityScope, auditableFields } = input;
+
+  // 1. Validate entityName non-empty
+  if (!entityName || entityName.trim() === "") {
+    return err(new InvalidEntityNameError(entityName ?? ""));
+  }
+
+  // 2. Validate entityScope
+  if (!VALID_SCOPES.includes(entityScope as (typeof VALID_SCOPES)[number])) {
+    return err(new InvalidEntityScopeError(entityScope ?? ""));
+  }
+
+  // 3. Validate auditableFields non-empty and all fields non-empty
+  if (!auditableFields || auditableFields.length === 0) {
+    return err(new InvalidAuditableFieldsError("empty array"));
+  }
+
+  const ELIGIBLE_FIELD_TYPES = ["scalar", "richtext", "array", "relation", "file"];
+  const resolvedFields: { fieldName: string; fieldType?: string }[] = [];
+
+  for (const field of auditableFields) {
+    const name = typeof field === "string" ? field : field.fieldName;
+    const fieldType = typeof field === "string" ? undefined : field.fieldType;
+
+    if (!name || name.trim() === "") {
+      return err(new InvalidAuditableFieldsError("empty field name"));
+    }
+    if (fieldType && !ELIGIBLE_FIELD_TYPES.includes(fieldType)) {
+      return err(
+        new InvalidAuditableFieldsError(`field '${name}' has ineligible type '${fieldType}'`),
+      );
+    }
+    resolvedFields.push(fieldType ? { fieldName: name, fieldType } : { fieldName: name });
+  }
+
+  // 4. Check duplicate entityName (with forUpdate for uniqueness)
+  const existing = await db
+    .selectFrom("AuditableEntity")
+    .selectAll()
+    .where("entityName", "=", entityName)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (existing) {
+    return err(new DuplicateEntityNameError(entityName));
+  }
+
+  // 5. Insert AuditableEntity with auditableFields as JSON string (includes fieldType)
+  const auditableEntity = await db
+    .insertInto("AuditableEntity")
+    .values({
+      entityName,
+      entityScope,
+      auditableFields: JSON.stringify(resolvedFields),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ auditableEntity: auditableEntity! });
+}

package/src/modules/audit/command/replaceAuditPolicy.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../../shared";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./replaceAuditPolicy";
+
+export const replaceAuditPolicy = defineCommand(permissions.replaceAuditPolicy, run);

package/src/modules/audit/command/replaceAuditPolicy.test.ts

@@ -0,0 +1,242 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PolicyNotFoundError,
+  InvalidStateError,
+  NoActivePolicyToReplaceError,
+  TargetMismatchError,
+  UnauthorizedError,
+} from "../lib/errors.generated";
+import { InsufficientPermissionError } from "../../../shared";
+import { draftReplacementPolicy, activePolicy, inactivePolicy } from "../testing/fixtures";
+import { run } from "./replaceAuditPolicy";
+import { replaceAuditPolicy } from "./replaceAuditPolicy.generated";
+
+const ctx = { actorId: "test-actor", permissions: ["audit:replaceAuditPolicy"] };
+
+describe("replaceAuditPolicy", () => {
+  it("atomically deactivates existing ACTIVE policy and activates DRAFT replacement", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy); // replacement policy (executeTakeFirst)
+    spies.select.mockReturnValueOnce([activePolicy]); // all ACTIVE policies for entity (execute)
+    spies.update
+      .mockReturnValueOnce({ ...activePolicy, status: "INACTIVE" }) // deactivated
+      .mockReturnValueOnce({ ...draftReplacementPolicy, status: "ACTIVE" }); // activated
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.deactivatedPolicy).toBeDefined();
+      expect(result.value.activatedPolicy).toBeDefined();
+    }
+  });
+
+  it("existing policy is INACTIVE after replacement", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy);
+    spies.select.mockReturnValueOnce([activePolicy]);
+    spies.update
+      .mockReturnValueOnce({ ...activePolicy, status: "INACTIVE" })
+      .mockReturnValueOnce({ ...draftReplacementPolicy, status: "ACTIVE" });
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.deactivatedPolicy.status).toBe("INACTIVE");
+    }
+  });
+
+  it("replacement policy is ACTIVE after replacement", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy);
+    spies.select.mockReturnValueOnce([activePolicy]);
+    spies.update
+      .mockReturnValueOnce({ ...activePolicy, status: "INACTIVE" })
+      .mockReturnValueOnce({ ...draftReplacementPolicy, status: "ACTIVE" });
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.activatedPolicy.status).toBe("ACTIVE");
+    }
+  });
+
+  it("no gap in audit coverage during replacement", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy);
+    spies.select.mockReturnValueOnce([activePolicy]);
+    spies.update
+      .mockReturnValueOnce({ ...activePolicy, status: "INACTIVE" })
+      .mockReturnValueOnce({ ...draftReplacementPolicy, status: "ACTIVE" });
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    // Both updates happen in the same transaction, ensuring no gap in audit coverage
+    expect(spies.update).toHaveBeenCalledTimes(2);
+    // Verify deactivation then activation order via set calls
+    expect(spies.set).toHaveBeenNthCalledWith(1, expect.objectContaining({ status: "INACTIVE" }));
+    expect(spies.set).toHaveBeenNthCalledWith(2, expect.objectContaining({ status: "ACTIVE" }));
+  });
+
+  it("rejects when replacement policy is not in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activePolicy); // not DRAFT
+
+    const result = await run(db, { replacementPolicyId: activePolicy.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+
+  it("rejects when replacement policy is ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activePolicy);
+
+    const result = await run(db, { replacementPolicyId: activePolicy.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+
+  it("rejects when replacement policy is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactivePolicy);
+
+    const result = await run(db, { replacementPolicyId: inactivePolicy.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateError);
+    }
+  });
+
+  it("rejects when no existing ACTIVE policy for the same entity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy);
+    spies.select.mockReturnValueOnce([]); // no ACTIVE policies for this entity
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NoActivePolicyToReplaceError);
+    }
+  });
+
+  it("rejects when replacement targets different operationType than existing ACTIVE policy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy);
+    spies.select.mockReturnValueOnce([
+      {
+        ...activePolicy,
+        operationType: "DELETE",
+      },
+    ]);
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(TargetMismatchError);
+    }
+  });
+
+  it("rejects when replacement targets different companyId than existing ACTIVE policy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy);
+    spies.select.mockReturnValueOnce([
+      {
+        ...activePolicy,
+        companyId: "different-company",
+      },
+    ]);
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(TargetMismatchError);
+    }
+  });
+
+  it("selects correct ACTIVE policy when multiple ACTIVE policies exist for the same entity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const deleteActive = { ...activePolicy, id: "policy-delete", operationType: "DELETE" };
+    // Replacement targets UPDATE operation
+    spies.select.mockReturnValueOnce(draftReplacementPolicy);
+    // All ACTIVE policies for this entity returned by execute()
+    // The implementation filters in-memory by companyId + operationType
+    spies.select.mockReturnValueOnce([deleteActive, activePolicy]);
+    spies.update
+      .mockReturnValueOnce({ ...activePolicy, status: "INACTIVE" })
+      .mockReturnValueOnce({ ...draftReplacementPolicy, status: "ACTIVE" });
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.deactivatedPolicy.status).toBe("INACTIVE");
+      expect(result.value.activatedPolicy.status).toBe("ACTIVE");
+    }
+  });
+
+  it("rejects when replacement policy does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { replacementPolicyId: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PolicyNotFoundError);
+    }
+  });
+
+  it("rejects when caller lacks manageAuditPolicies permission", async () => {
+    const { db } = createMockDb<Transaction>();
+    const denied = { actorId: "test-actor", permissions: [] as string[] };
+    const cmd = replaceAuditPolicy();
+
+    const result = await cmd(db, { replacementPolicyId: draftReplacementPolicy.id }, denied);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InsufficientPermissionError);
+    }
+  });
+
+  it("rejects when company-scoped caller replaces policy for a different company", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy); // policy with companyId: "company-1"
+    const scopedCtx = { ...ctx, companyId: "company-2" };
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, scopedCtx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnauthorizedError);
+    }
+  });
+
+  it("rejects when global-scoped caller replaces company-scoped policy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(draftReplacementPolicy); // policy with companyId: "company-1"
+    const globalCtx = { ...ctx, companyId: null };
+
+    const result = await run(db, { replacementPolicyId: draftReplacementPolicy.id }, globalCtx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnauthorizedError);
+    }
+  });
+});

package/src/modules/audit/command/replaceAuditPolicy.ts

@@ -0,0 +1,91 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PolicyNotFoundError,
+  InvalidStateError,
+  NoActivePolicyToReplaceError,
+  TargetMismatchError,
+  UnauthorizedError,
+} from "../lib/errors.generated";
+
+export interface ReplaceAuditPolicyInput {
+  replacementPolicyId: string;
+}
+
+/**
+ * Function: replaceAuditPolicy
+ *
+ * Atomically replaces an existing ACTIVE audit policy with a DRAFT replacement.
+ * The existing ACTIVE policy is set to INACTIVE and the replacement is set to ACTIVE.
+ */
+export async function run(db: Transaction, input: ReplaceAuditPolicyInput, ctx: CommandContext) {
+  const { replacementPolicyId } = input;
+
+  // 1. Find replacement policy by ID with forUpdate
+  const replacement = await db
+    .selectFrom("AuditPolicy")
+    .selectAll()
+    .where("id", "=", replacementPolicyId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!replacement) {
+    return err(new PolicyNotFoundError(replacementPolicyId));
+  }
+
+  // Scope authorization checks
+  if (ctx.companyId !== undefined) {
+    if (ctx.companyId !== null && replacement.companyId !== ctx.companyId) {
+      return err(new UnauthorizedError(ctx.actorId));
+    }
+    if (ctx.companyId === null && replacement.companyId !== null) {
+      return err(new UnauthorizedError(ctx.actorId));
+    }
+  }
+
+  // 2. Not DRAFT → InvalidStateError
+  if (replacement.status !== "DRAFT") {
+    return err(new InvalidStateError(replacementPolicyId));
+  }
+
+  // 3. Find all ACTIVE policies for the same entityName (not filtered by companyId or operationType
+  //    so that TARGET_MISMATCH can fire when they differ)
+  const activePolicies = await db
+    .selectFrom("AuditPolicy")
+    .selectAll()
+    .where("entityName", "=", replacement.entityName)
+    .where("status", "=", "ACTIVE")
+    .forUpdate()
+    .execute();
+
+  if (activePolicies.length === 0) {
+    return err(new NoActivePolicyToReplaceError(replacementPolicyId));
+  }
+
+  // 4. Find the ACTIVE policy that matches the replacement's companyId + operationType
+  const existingActive = activePolicies.find(
+    (p) => p.companyId === replacement.companyId && p.operationType === replacement.operationType,
+  );
+
+  if (!existingActive) {
+    return err(new TargetMismatchError(replacementPolicyId));
+  }
+
+  // 5. Set existing ACTIVE policy to INACTIVE
+  const deactivatedPolicy = await db
+    .updateTable("AuditPolicy")
+    .set({ status: "INACTIVE", updatedAt: new Date() })
+    .where("id", "=", existingActive.id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 6. Set replacement policy to ACTIVE
+  const activatedPolicy = await db
+    .updateTable("AuditPolicy")
+    .set({ status: "ACTIVE", updatedAt: new Date() })
+    .where("id", "=", replacementPolicyId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ deactivatedPolicy: deactivatedPolicy!, activatedPolicy: activatedPolicy! });
+}