@emkodev/emkore 1.0.3

package/test/unit/authorization.test.ts

@@ -0,0 +1,101 @@
+import { test, expect } from "bun:test";
+import { AuthorizationInterceptor, ResourceScope } from "../../mod.ts";
+
+test("AuthorizationInterceptor - scope satisfaction matrix", () => {
+  // Access the private static field for testing
+  const interceptor = new AuthorizationInterceptor();
+
+  // Test that the SCOPE_SATISFIES map is correctly initialized
+  const scopeSatisfies = (interceptor as any as {
+    constructor: {
+      SCOPE_SATISFIES: Map<string, Set<string>>;
+    };
+  }).constructor.SCOPE_SATISFIES;
+
+  // ALL scope should satisfy all other scopes
+  expect(
+    scopeSatisfies.get(ResourceScope.ALL)?.has(ResourceScope.ALL),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.ALL)?.has(ResourceScope.BUSINESS),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.ALL)?.has(ResourceScope.PROJECT),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.ALL)?.has(ResourceScope.TEAM),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.ALL)?.has(ResourceScope.OWNED),
+  ).toEqual(true);
+
+  // BUSINESS scope should satisfy BUSINESS, PROJECT, TEAM, and OWNED
+  expect(
+    scopeSatisfies.get(ResourceScope.BUSINESS)?.has(ResourceScope.ALL),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.BUSINESS)?.has(ResourceScope.BUSINESS),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.BUSINESS)?.has(ResourceScope.PROJECT),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.BUSINESS)?.has(ResourceScope.TEAM),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.BUSINESS)?.has(ResourceScope.OWNED),
+  ).toEqual(true);
+
+  // PROJECT scope should satisfy PROJECT and OWNED (parallel to TEAM)
+  expect(
+    scopeSatisfies.get(ResourceScope.PROJECT)?.has(ResourceScope.ALL),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.PROJECT)?.has(ResourceScope.BUSINESS),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.PROJECT)?.has(ResourceScope.PROJECT),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.PROJECT)?.has(ResourceScope.TEAM),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.PROJECT)?.has(ResourceScope.OWNED),
+  ).toEqual(true);
+
+  // TEAM scope should satisfy TEAM and OWNED (parallel to PROJECT)
+  expect(
+    scopeSatisfies.get(ResourceScope.TEAM)?.has(ResourceScope.ALL),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.TEAM)?.has(ResourceScope.BUSINESS),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.TEAM)?.has(ResourceScope.PROJECT),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.TEAM)?.has(ResourceScope.TEAM),
+  ).toEqual(true);
+  expect(
+    scopeSatisfies.get(ResourceScope.TEAM)?.has(ResourceScope.OWNED),
+  ).toEqual(true);
+
+  // OWNED scope should only satisfy OWNED
+  expect(
+    scopeSatisfies.get(ResourceScope.OWNED)?.has(ResourceScope.ALL),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.OWNED)?.has(ResourceScope.BUSINESS),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.OWNED)?.has(ResourceScope.PROJECT),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.OWNED)?.has(ResourceScope.TEAM),
+  ).toEqual(false);
+  expect(
+    scopeSatisfies.get(ResourceScope.OWNED)?.has(ResourceScope.OWNED),
+  ).toEqual(true);
+
+  console.log("✓ Scope satisfaction matrix is correctly initialized");
+});

package/test/unit/entity.test.ts

@@ -0,0 +1,95 @@
+import { test, expect } from "bun:test";
+import { type Dto, Entity } from "../../mod.ts";
+
+class TestEntity extends Entity {
+  constructor(dto: Dto) {
+    super(dto);
+  }
+}
+
+test("Entity - constructor", () => {
+  const dto: Dto = {
+    id: "test-123",
+    ownerId: "owner-456",
+    createdAt: "2024-01-01T00:00:00.000Z",
+    updatedAt: "2024-01-02T00:00:00.000Z",
+  };
+
+  const entity = new TestEntity(dto);
+
+  expect(entity.id).toEqual("test-123");
+  expect(entity.ownerId).toEqual("owner-456");
+  expect(entity.createdAt.toISOString()).toEqual("2024-01-01T00:00:00.000Z");
+  expect(entity.updatedAt.toISOString()).toEqual("2024-01-02T00:00:00.000Z");
+  expect(entity.deletedAt).toEqual(undefined);
+  expect(entity.isDeleted).toEqual(false);
+});
+
+test("Entity - with deletedAt", () => {
+  const dto: Dto = {
+    id: "test-123",
+    ownerId: "owner-456",
+    createdAt: "2024-01-01T00:00:00.000Z",
+    updatedAt: "2024-01-02T00:00:00.000Z",
+    deletedAt: "2024-01-03T00:00:00.000Z",
+  };
+
+  const entity = new TestEntity(dto);
+
+  expect(entity.deletedAt?.toISOString()).toEqual("2024-01-03T00:00:00.000Z");
+  expect(entity.isDeleted).toEqual(true);
+});
+
+test("Entity - toDto", () => {
+  const dto: Dto = {
+    id: "test-123",
+    ownerId: "owner-456",
+    createdAt: "2024-01-01T00:00:00.000Z",
+    updatedAt: "2024-01-02T00:00:00.000Z",
+    deletedAt: "2024-01-03T00:00:00.000Z",
+  };
+
+  const entity = new TestEntity(dto);
+  const result = entity.toDto();
+
+  expect(result.id).toEqual(dto.id);
+  expect(result.ownerId).toEqual(dto.ownerId);
+  expect(result.createdAt).toEqual(dto.createdAt);
+  expect(result.updatedAt).toEqual(dto.updatedAt);
+  expect(result.deletedAt).toEqual(dto.deletedAt);
+});
+
+test("Entity - generateId with valid prefix", () => {
+  const id = Entity.generateId("abcd");
+
+  expect(id.startsWith("abcd-")).toEqual(true);
+  expect(id.length).toEqual(41); // 4 (prefix) + 1 (-) + 36 (uuid)
+
+  // Test UUID format after prefix
+  const uuidPart = id.slice(5);
+  const uuidRegex =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  expect(uuidRegex.test(uuidPart)).toEqual(true);
+});
+
+test("Entity - generateId with invalid prefix", () => {
+  // Too short
+  expect(() => Entity.generateId("abc")).toThrow(
+    "Prefix must be exactly four hexadecimal characters",
+  );
+
+  // Too long
+  expect(() => Entity.generateId("abcde")).toThrow(
+    "Prefix must be exactly four hexadecimal characters",
+  );
+
+  // Invalid characters
+  expect(() => Entity.generateId("ghij")).toThrow(
+    "Prefix must be exactly four hexadecimal characters",
+  );
+
+  // With hyphen
+  expect(() => Entity.generateId("ab-d")).toThrow(
+    "Prefix must be exactly four hexadecimal characters",
+  );
+});

package/test/unit/money.test.ts

@@ -0,0 +1,480 @@
+import { test, expect } from "bun:test";
+import { Money } from "../../src/common/type/money.class.ts";
+
+// ============================================================================
+// Construction Tests
+// ============================================================================
+
+test("Money - constructor with valid cents", () => {
+  const money = new Money(14999, "USD");
+  expect(money.cents).toEqual(14999);
+  expect(money.currency).toEqual("USD");
+});
+
+test("Money - constructor normalizes currency to uppercase", () => {
+  const money = new Money(100, "usd");
+  expect(money.currency).toEqual("USD");
+});
+
+test("Money - constructor rounds fractional cents", () => {
+  const money = new Money(149.99, "USD");
+  expect(money.cents).toEqual(150);
+});
+
+test("Money - constructor throws on null cents", () => {
+  expect(() => new Money(null as unknown as number, "USD")).toThrow(
+    "Money value cannot be null - amount is required",
+  );
+});
+
+test("Money - constructor throws on undefined cents", () => {
+  expect(() => new Money(undefined as unknown as number, "USD")).toThrow(
+    "Money value cannot be null - amount is required",
+  );
+});
+
+test("Money - constructor throws on empty currency", () => {
+  expect(() => new Money(100, "")).toThrow(
+    "Currency must be a non-empty string",
+  );
+});
+
+test("Money - constructor throws on non-string currency", () => {
+  expect(() => new Money(100, null as unknown as string)).toThrow(
+    "Currency must be a non-empty string",
+  );
+});
+
+test("Money - constructor requires currency", () => {
+  const money = new Money(100, "USD");
+  expect(money.currency).toEqual("USD");
+  expect(money.cents).toEqual(100);
+});
+
+// ============================================================================
+// Factory Methods
+// ============================================================================
+
+test("Money.fromCents - creates Money from cents", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.cents).toEqual(14999);
+  expect(money.currency).toEqual("USD");
+});
+
+test("Money.fromMajorUnits - converts dollars to cents", () => {
+  const money = Money.fromMajorUnits(149.99, "USD");
+  expect(money.cents).toEqual(14999);
+});
+
+test("Money.fromMajorUnits - handles integer amounts", () => {
+  const money = Money.fromMajorUnits(100, "USD");
+  expect(money.cents).toEqual(10000);
+});
+
+test("Money.fromMajorUnits - rounds fractional cents", () => {
+  const money = Money.fromMajorUnits(149.999, "USD");
+  expect(money.cents).toEqual(15000); // 149.999 * 100 = 14999.9 → 15000
+});
+
+test("Money.fromMajorUnits - handles floating point precision", () => {
+  // 0.1 + 0.2 = 0.30000000000000004 in JavaScript
+  const money = Money.fromMajorUnits(0.1 + 0.2, "USD");
+  expect(money.cents).toEqual(30); // Should round to 30 cents
+});
+
+test("Money.zero - creates zero Money", () => {
+  const money = Money.zero("EUR");
+  expect(money.cents).toEqual(0);
+  expect(money.currency).toEqual("EUR");
+});
+
+test("Money.zero - creates zero with specified currency", () => {
+  const usd = Money.zero("USD");
+  expect(usd.currency).toEqual("USD");
+  expect(usd.cents).toEqual(0);
+
+  const eur = Money.zero("EUR");
+  expect(eur.currency).toEqual("EUR");
+  expect(eur.cents).toEqual(0);
+});
+
+// ============================================================================
+// Arithmetic Operations
+// ============================================================================
+
+test("Money.add - adds two Money amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(50, "USD");
+  const result = a.add(b);
+
+  expect(result.cents).toEqual(150);
+  expect(result.currency).toEqual("USD");
+});
+
+test("Money.add - returns new instance (immutability)", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(50, "USD");
+  const result = a.add(b);
+
+  expect(a.cents).toEqual(100); // Original unchanged
+  expect(b.cents).toEqual(50); // Original unchanged
+  expect(result.cents).toEqual(150);
+});
+
+test("Money.add - throws on currency mismatch", () => {
+  const usd = Money.fromCents(100, "USD");
+  const eur = Money.fromCents(100, "EUR");
+
+  expect(() => usd.add(eur)).toThrow(
+    "Cannot operate on Money with different currencies: USD and EUR",
+  );
+});
+
+test("Money.subtract - subtracts two Money amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(30, "USD");
+  const result = a.subtract(b);
+
+  expect(result.cents).toEqual(70);
+});
+
+test("Money.subtract - can result in negative", () => {
+  const a = Money.fromCents(50, "USD");
+  const b = Money.fromCents(100, "USD");
+  const result = a.subtract(b);
+
+  expect(result.cents).toEqual(-50);
+});
+
+test("Money.subtract - throws on currency mismatch", () => {
+  const usd = Money.fromCents(100, "USD");
+  const eur = Money.fromCents(50, "EUR");
+
+  expect(() => usd.subtract(eur)).toThrow(
+    "different currencies",
+  );
+});
+
+test("Money.multiply - multiplies by integer", () => {
+  const money = Money.fromCents(100, "USD");
+  const result = money.multiply(3);
+
+  expect(result.cents).toEqual(300);
+});
+
+test("Money.multiply - multiplies by decimal", () => {
+  const money = Money.fromCents(100, "USD");
+  const result = money.multiply(1.5);
+
+  expect(result.cents).toEqual(150);
+});
+
+test("Money.multiply - rounds fractional result", () => {
+  const money = Money.fromCents(100, "USD");
+  const result = money.multiply(0.33);
+
+  expect(result.cents).toEqual(33); // 100 * 0.33 = 33
+});
+
+test("Money.multiply - handles tax calculation", () => {
+  const price = Money.fromCents(10000, "USD"); // $100.00
+  const withTax = price.multiply(1.08); // 8% tax
+
+  expect(withTax.cents).toEqual(10800); // $108.00
+});
+
+test("Money.multiply - returns new instance", () => {
+  const money = Money.fromCents(100, "USD");
+  const result = money.multiply(2);
+
+  expect(money.cents).toEqual(100); // Original unchanged
+  expect(result.cents).toEqual(200);
+});
+
+test("Money.divide - divides by integer", () => {
+  const money = Money.fromCents(100, "USD");
+  const result = money.divide(2);
+
+  expect(result.cents).toEqual(50);
+});
+
+test("Money.divide - rounds fractional result", () => {
+  const money = Money.fromCents(100, "USD");
+  const result = money.divide(3);
+
+  expect(result.cents).toEqual(33); // 100 / 3 = 33.333... → 33
+});
+
+test("Money.divide - throws on division by zero", () => {
+  const money = Money.fromCents(100, "USD");
+
+  expect(() => money.divide(0)).toThrow(
+    "Cannot divide money by zero",
+  );
+});
+
+test("Money.divide - returns new instance", () => {
+  const money = Money.fromCents(100, "USD");
+  const result = money.divide(2);
+
+  expect(money.cents).toEqual(100); // Original unchanged
+  expect(result.cents).toEqual(50);
+});
+
+// ============================================================================
+// Comparison Operations
+// ============================================================================
+
+test("Money.equals - returns true for equal amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(100, "USD");
+
+  expect(a.equals(b)).toEqual(true);
+});
+
+test("Money.equals - returns false for different amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(50, "USD");
+
+  expect(a.equals(b)).toEqual(false);
+});
+
+test("Money.equals - throws on currency mismatch", () => {
+  const usd = Money.fromCents(100, "USD");
+  const eur = Money.fromCents(100, "EUR");
+
+  expect(() => usd.equals(eur)).toThrow(
+    "different currencies",
+  );
+});
+
+test("Money.lessThan - compares amounts", () => {
+  const a = Money.fromCents(50, "USD");
+  const b = Money.fromCents(100, "USD");
+
+  expect(a.lessThan(b)).toEqual(true);
+  expect(b.lessThan(a)).toEqual(false);
+});
+
+test("Money.lessThan - returns false for equal amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(100, "USD");
+
+  expect(a.lessThan(b)).toEqual(false);
+});
+
+test("Money.lessThan - throws on currency mismatch", () => {
+  const usd = Money.fromCents(50, "USD");
+  const eur = Money.fromCents(100, "EUR");
+
+  expect(() => usd.lessThan(eur)).toThrow(
+    "different currencies",
+  );
+});
+
+test("Money.lessThanOrEqual - compares amounts", () => {
+  const a = Money.fromCents(50, "USD");
+  const b = Money.fromCents(100, "USD");
+  const c = Money.fromCents(50, "USD");
+
+  expect(a.lessThanOrEqual(b)).toEqual(true);
+  expect(a.lessThanOrEqual(c)).toEqual(true);
+  expect(b.lessThanOrEqual(a)).toEqual(false);
+});
+
+test("Money.greaterThan - compares amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(50, "USD");
+
+  expect(a.greaterThan(b)).toEqual(true);
+  expect(b.greaterThan(a)).toEqual(false);
+});
+
+test("Money.greaterThan - returns false for equal amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(100, "USD");
+
+  expect(a.greaterThan(b)).toEqual(false);
+});
+
+test("Money.greaterThanOrEqual - compares amounts", () => {
+  const a = Money.fromCents(100, "USD");
+  const b = Money.fromCents(50, "USD");
+  const c = Money.fromCents(100, "USD");
+
+  expect(a.greaterThanOrEqual(b)).toEqual(true);
+  expect(a.greaterThanOrEqual(c)).toEqual(true);
+  expect(b.greaterThanOrEqual(a)).toEqual(false);
+});
+
+// ============================================================================
+// Formatting Tests
+// ============================================================================
+
+test("Money.format - formats USD with en-US locale", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.format("en-US")).toEqual("$149.99");
+});
+
+test("Money.format - formats EUR with en-US locale", () => {
+  const money = Money.fromCents(9999, "EUR");
+  expect(money.format("en-US")).toEqual("€99.99");
+});
+
+test("Money.format - formats USD with de-DE locale", () => {
+  const money = Money.fromCents(14999, "USD");
+  const formatted = money.format("de-DE");
+  // German locale uses comma as decimal separator
+  expect(formatted.includes("149,99")).toEqual(true);
+});
+
+test("Money.format - handles zero", () => {
+  const money = Money.zero("USD");
+  expect(money.format("en-US")).toEqual("$0.00");
+});
+
+test("Money.format - handles negative amounts", () => {
+  const money = Money.fromCents(-5000, "USD");
+  expect(money.format("en-US")).toEqual("-$50.00");
+});
+
+test("Money.format - handles large amounts", () => {
+  const money = Money.fromCents(123456789, "USD");
+  expect(money.format("en-US")).toEqual("$1,234,567.89");
+});
+
+test("Money.format - defaults to en-US locale", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.format()).toEqual("$149.99");
+});
+
+test("Money.formatNumber - formats without currency symbol", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.formatNumber("en-US")).toEqual("149.99");
+});
+
+test("Money.formatNumber - formats with de-DE locale", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.formatNumber("de-DE")).toEqual("149,99");
+});
+
+test("Money.formatNumber - handles zero", () => {
+  const money = Money.zero("USD");
+  expect(money.formatNumber("en-US")).toEqual("0.00");
+});
+
+test("Money.formatNumber - handles negative", () => {
+  const money = Money.fromCents(-5000, "USD");
+  expect(money.formatNumber("en-US")).toEqual("-50.00");
+});
+
+test("Money.formatNumber - defaults to en-US locale", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.formatNumber()).toEqual("149.99");
+});
+
+// ============================================================================
+// Serialization Tests
+// ============================================================================
+
+test("Money.toString - converts to decimal string", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.toString()).toEqual("149.99");
+});
+
+test("Money.toString - handles zero", () => {
+  const money = Money.zero("USD");
+  expect(money.toString()).toEqual("0");
+});
+
+test("Money.toString - handles negative", () => {
+  const money = Money.fromCents(-5000, "USD");
+  expect(money.toString()).toEqual("-50");
+});
+
+test("Money.toJson - returns cents as number", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.toJson()).toEqual(14999);
+});
+
+test("Money.toJson - handles zero", () => {
+  const money = Money.zero("USD");
+  expect(money.toJson()).toEqual(0);
+});
+
+test("Money.toJson - handles negative", () => {
+  const money = Money.fromCents(-5000, "USD");
+  expect(money.toJson()).toEqual(-5000);
+});
+
+// ============================================================================
+// Getters
+// ============================================================================
+
+test("Money.cents - returns amount in cents", () => {
+  const money = Money.fromCents(14999, "USD");
+  expect(money.cents).toEqual(14999);
+});
+
+test("Money.currency - returns currency code", () => {
+  const money = Money.fromCents(100, "EUR");
+  expect(money.currency).toEqual("EUR");
+});
+
+// ============================================================================
+// Edge Cases
+// ============================================================================
+
+test("Money - handles very large amounts", () => {
+  const money = Money.fromCents(Number.MAX_SAFE_INTEGER, "USD");
+  expect(money.cents).toEqual(Number.MAX_SAFE_INTEGER);
+});
+
+test("Money - handles very small negative amounts", () => {
+  const money = Money.fromCents(-1, "USD");
+  expect(money.cents).toEqual(-1);
+  expect(money.format("en-US")).toEqual("-$0.01");
+});
+
+test("Money - arithmetic preserves currency", () => {
+  const eur = Money.fromCents(100, "EUR");
+  const result = eur.multiply(2).add(eur).subtract(eur);
+
+  expect(result.currency).toEqual("EUR");
+});
+
+test("Money - supports Japanese Yen (no minor units)", () => {
+  const yen = Money.fromCents(1000000, "JPY");
+  expect(yen.format("en-US")).toEqual("¥10,000");
+});
+
+test("Money - complex calculation maintains precision", () => {
+  const item1 = Money.fromCents(1999, "USD"); // $19.99
+  const item2 = Money.fromCents(2999, "USD"); // $29.99
+  const subtotal = item1.add(item2); // $49.98
+  const total = subtotal.multiply(1.08); // $53.98 (rounded)
+
+  expect(subtotal.cents).toEqual(4998);
+  expect(total.cents).toEqual(5398);
+  expect(total.format("en-US")).toEqual("$53.98");
+});
+
+test("Money - chained operations", () => {
+  const result = Money.fromCents(100, "USD")
+    .multiply(3) // 300
+    .add(Money.fromCents(50, "USD")) // 350
+    .subtract(Money.fromCents(100, "USD")) // 250
+    .divide(2); // 125
+
+  expect(result.cents).toEqual(125);
+});
+
+test("Money - percentage discount calculation", () => {
+  const price = Money.fromCents(10000, "USD"); // $100.00
+  const discount = price.multiply(0.2); // 20% discount = $20.00
+  const finalPrice = price.subtract(discount); // $80.00
+
+  expect(discount.cents).toEqual(2000);
+  expect(finalPrice.cents).toEqual(8000);
+  expect(finalPrice.format("en-US")).toEqual("$80.00");
+});