Modular Monolith و DDD: حدود واضحة من غير network

// anemic.js: الـ order كـ object فاضي، وكل حتة في الـ code بتعدّل فيه زي ما هي عايزة
export const order = { id: "o1", status: "draft", lines: [], total: 0 };

// routes/cart.js
order.lines.push({ sku: "mug", qty: 2, price: 99.5 });
order.lines.push({ sku: "tshirt", qty: -1, price: 250 });   // محدش منع ده
order.total = order.lines.reduce((s, l) => s + l.qty * l.price, 0);

// routes/admin.js
order.status = "paid";                                       // من غير ما حد يدفع

// jobs/cleanup.js
if (order.status !== "shipped") order.status = "cancelled";  // اتلغى بعد الدفع

// routes/coupons.js
order.lines.push({ sku: "gift", qty: 1, price: 0.1 + 0.2 }); // الـ total ما اتحسبش تاني، و 0.30000000000000004
console.log(order);

$ node anemic.js
{
  id: 'o1',
  status: 'cancelled',
  lines: [
    { sku: 'mug', qty: 2, price: 99.5 },
    { sku: 'tshirt', qty: -1, price: 250 },
    { sku: 'gift', qty: 1, price: 0.30000000000000004 }
  ],
  total: -51
}

// monolith.js: Money كـ value object، و Order كـ aggregate بالـ invariants والـ events، و bus بين الـ modules، و checker للحدود
import { posix } from "node:path";

export class DomainError extends Error {
  constructor(code, message = code) { super(message); this.code = code; }
}

export function money(minor, currency) {
  if (!Number.isInteger(minor)) throw new DomainError("INVALID_AMOUNT", `المبلغ لازم integer بالقروش: ${minor}`);
  if (!/^[A-Z]{3}$/.test(currency ?? "")) throw new DomainError("INVALID_CURRENCY", `currency مش مفهومة: ${currency}`);
  return Object.freeze({ minor, currency });
}

export function addMoney(a, b) {
  if (a.currency !== b.currency) throw new DomainError("CURRENCY_MISMATCH", `${a.currency} و ${b.currency}`);
  return money(a.minor + b.minor, a.currency);
}

export function multiplyMoney(m, n) {
  if (!Number.isInteger(n)) throw new DomainError("INVALID_QTY");
  return money(m.minor * n, m.currency);
}

export const equalsMoney = (a, b) => a.minor === b.minor && a.currency === b.currency;

export function formatMoney(m) {
  const abs = Math.abs(m.minor);
  return `${m.minor < 0 ? "-" : ""}${m.currency} ${Math.floor(abs / 100)}.${String(abs % 100).padStart(2, "0")}`;
}

export function createOrder({ id, currency }) {
  let status = "draft";
  const lines = new Map();
  let events = [];
  const fail = (code, msg) => { throw new DomainError(code, msg); };
  const draftOnly = () => status !== "draft" && fail("NOT_DRAFT", `الـ order ${status}`);
  const total = () => [...lines.values()].reduce((s, l) => addMoney(s, multiplyMoney(l.unitPrice, l.qty)), money(0, currency));
  return {
    id,
    get status() { return status; },
    addLine(sku, qty, unitPrice) {
      draftOnly();
      if (!Number.isInteger(qty) || qty < 1 || qty > 99) fail("INVALID_QTY", `qty: ${qty}`);
      if (unitPrice.currency !== currency) fail("CURRENCY_MISMATCH", `${unitPrice.currency} في order بـ ${currency}`);
      const cur = lines.get(sku);
      if (cur) {
        if (cur.qty + qty > 99) fail("INVALID_QTY", `qty: ${cur.qty + qty}`);
        cur.qty += qty;
      } else lines.set(sku, { sku, qty, unitPrice });
    },
    removeLine(sku) {
      draftOnly();
      if (!lines.delete(sku)) fail("UNKNOWN_LINE", sku);
    },
    total,
    place() {
      draftOnly();
      if (!lines.size) fail("EMPTY_ORDER");
      status = "placed";
      events.push({ type: "OrderPlaced", orderId: id, total: total(), lines: [...lines.values()].map(({ sku, qty }) => ({ sku, qty })) });
    },
    pay(amount) {
      if (status === "paid") fail("ALREADY_PAID");
      if (status !== "placed") fail("NOT_PLACED", `الـ order ${status}`);
      if (!equalsMoney(amount, total())) fail("AMOUNT_MISMATCH", `${formatMoney(amount)} قصاد ${formatMoney(total())}`);
      status = "paid";
      events.push({ type: "OrderPaid", orderId: id, amount });
    },
    cancel(reason) {
      if (status === "paid") fail("ALREADY_PAID");
      if (status === "cancelled") fail("ALREADY_
…

$ node lab.js
o1: اتنين mug بتسعة وتسعين ونص، و tshirt واحد بمِيتين وخمسين:
   event OrderPlaced o1
   event StockReserved o1
  status: placed و total: EGP 449.00
   event OrderPaid o1
  بعد الدفع: paid و invoices: [{"orderId":"o1","amount":"EGP 449.00"}]
  الـ stock: mug 3 و tshirt 1

o2: تلاتة tshirt والباقي واحد بس:
   event OrderPlaced o2
   event StockRejected o2 tshirt
   event OrderCancelled o2
  الـ status بعد ما الـ events خلصت: cancelled و الـ stock: tshirt 1

الـ invariants بتاعة الـ aggregate:
   دفع بمبلغ غلط            ← AMOUNT_MISMATCH
   دفع order اتدفع قبل كده  ← ALREADY_PAID
   إلغاء order اتدفع        ← ALREADY_PAID
   qty بـ صفر               ← INVALID_QTY
   دولار في order بالجنيه   ← CURRENCY_MISMATCH
   place من غير lines       ← EMPTY_ORDER
   مبلغ بكسور قروش          ← INVALID_AMOUNT

الـ handler اللي بيحاول يعدّل في الـ event:
   {"delivered":["good"],"failed":[{"module":"evil","error":"Cannot assign to read only property 'orderId' of object '#<Object>'"}]}

analyzeModules على codebase.naive.js:
  deps: {"orders":["billing","inventory"],"inventory":["orders"],"billing":[],"shared":[]}
  DEEP-IMPORT    src/orders/service.js  src/inventory/stock.repo.js
  FO
…

// codebase.naive.js: الـ monolith زي ما هو النهارده، كل حتة بتمد إيدها في التانية
export const owners = { orders: ["orders", "order_lines"], inventory: ["stock", "reservations"], billing: ["invoices"] };
export const files = {
  "src/orders/service.js": `
import { db } from "../shared/db.js";
import { stockFor } from "../inventory/stock.repo.js";
import { createInvoice } from "../billing/index.js";
export async function placeOrder(order) {
  for (const l of order.lines) if ((await stockFor(l.sku)) < l.qty) throw new Error("out of stock");
  await db.query("UPDATE stock SET qty = qty - $1 WHERE sku = $2", [order.lines[0].qty, order.lines[0].sku]);
  await createInvoice(order);
}`,
  "src/inventory/stock.repo.js": `
import { db } from "../shared/db.js";
import { orderLines } from "../orders/service.js";
export const stockFor = async (sku) => (await db.query("SELECT qty FROM stock WHERE sku = $1", [sku])).rows[0]?.qty ?? 0;`,
  "src/billing/index.js": `
import { db } from "../shared/db.js";
export async function createInvoice(order) {
  const { rows } = await db.query("SELECT o.id, sum(l.qty * l.price) FROM orders o JOIN order_lines l ON l.order_id = o.id WHERE o.id = $1", [order.id]);
  await db.query("INSERT INTO invoices (order_id, total) VALUES ($1, $2)", [rows[0].id, rows[0].sum]);
}`,
  "src/shared/db.js": `export const db = { query: async () => ({ rows: [] }) };`,
};

// codebase.js: نفس الـ modules، كل واحد ليه index.js هو الـ public API، والـ data بتعدّي في events أو function calls
export const owners = { orders: ["orders", "order_lines"], inventory: ["stock", "reservations"], billing: ["invoices"] };
export const files = {
  "src/orders/index.js": `
export { placeOrder, payOrder } from "./service.js";
export const ORDER_EVENTS = ["OrderPlaced", "OrderPaid", "OrderCancelled"];`,
  "src/orders/service.js": `
import { db } from "../shared/db.js";
import { bus } from "../shared/bus.js";
import { reserve } from "../inventory/index.js";
export async function placeOrder(order) {
  await reserve(order.id, order.lines);
  await db.query("INSERT INTO orders (id, status) VALUES ($1, 'placed')", [order.id]);
  await bus.publish({ type: "OrderPlaced", orderId: order.id, total: order.total });
}
export async function payOrder(id) { await db.query("UPDATE orders SET status = 'paid' WHERE id = $1", [id]); }`,
  "src/inventory/index.js": `
export { reserve } from "./stock.repo.js";`,
  "src/inventory/stock.repo.js": `
import { db } from "../shared/db.js";
export async function reserve(orderId, lines) {
  for (const l of lines) await db.query("INSERT INTO reservations (order_id, sku, qty) VALUES ($1, $2, $3)", [orderId, l.sku, l.qty]);
}`,
  "src/billing/index.js": `
import { db } from "../shared/db.js";
import { bus } from "../shared/bus.js";
bus.subscribe("OrderPlaced", "billing", async (e) => {
  await db.query("INSERT INTO invoices (order_id, total) VALUES ($1, $2)", [e.orderId, e.total.minor]);
});`,
  "src/shared/db.js": `export const db = { query: async () => ({ rows: [] }) };`,
  "src/shared/bus.js": `export const bus = { publish: async () => {}, subscribe: () => {} };`,
};