@shirudo/ddd-kit 0.9.8 → 0.11.0

package/README.md

@@ -2,6 +2,10 @@
 
 Composable TypeScript toolkit for tactical Domain-Driven Design.
 
+> **⚠️ BETA WARNING**
+>
+> This library is currently in beta. The API is subject to change until a stable 1.0.0 release. Breaking changes may occur in minor versions during the beta phase. Please pin your dependencies to specific versions.
+
 ## Badges
 
 ![npm version](https://img.shields.io/npm/v/@shirudo/ddd-kit)
@@ -37,9 +41,9 @@ pnpm add @shirudo/ddd-kit
 Here's a minimal example showing how to create and use a Value Object:
 
 ```typescript
-import { vo, type ValueObject } from "@shirudo/ddd-kit";
+import { vo, type VO } from "@shirudo/ddd-kit";
 
-type EmailAddress = ValueObject<{
+type EmailAddress = VO<{
   value: string;
 }>;
 
@@ -125,10 +129,10 @@ The `Result<T, E>` type provides functional error handling without exceptions. I
 ### Creating a Value Object
 
 ```typescript
-import { vo, voEquals, voEqualsExcept, voWithValidation, type ValueObject } from "@shirudo/ddd-kit";
+import { vo, voEquals, voEqualsExcept, voWithValidation, type VO } from "@shirudo/ddd-kit";
 
-// Simple value object
-type Money = ValueObject<{
+// Simple value object (Functional Style)
+type Money = VO<{
   amount: number;
   currency: string;
 }>;
@@ -136,6 +140,22 @@ type Money = ValueObject<{
 const price = vo({ amount: 99.99, currency: "USD" });
 // price is deeply immutable - nested objects and arrays are also frozen
 
+// Class-based Value Object (OOP Style)
+import { ValueObject } from "@shirudo/ddd-kit";
+
+class Address extends ValueObject<{ street: string; city: string }> {
+  constructor(props: { street: string; city: string }) {
+    super(props);
+  }
+
+  get street(): string {
+    return this.props.street;
+  }
+}
+
+const address = new Address({ street: "Main St", city: "New York" });
+// address.props is immutable
+
 // Value object with validation (returns Result)
 const result = voWithValidation(
   { amount: 100, currency: "USD" },
@@ -458,7 +478,7 @@ import {
 type CreateOrderCommand = Command & {
   type: "CreateOrder";
   customerId: string;
-  items: Array<{ productId: string; quantity: number }>;
+  items: Array<{ productId: string; quantity: number; price: number }>;
 };
 
 // Create a command handler
@@ -471,7 +491,14 @@ const createOrderHandler: CommandHandler<CreateOrderCommand, string> = async (
   }
 
   // Perform business logic
-  const order = Order.create(cmd.customerId, cmd.items);
+  const orderId = `order-${Date.now()}` as OrderId;
+  const order = Order.create(orderId, cmd.customerId);
+
+  // Add items to the order
+  for (const item of cmd.items) {
+    order.addItem(item.productId, item.quantity, item.price);
+  }
+
   await repository.save(order);
 
   return ok(order.id);
@@ -481,7 +508,7 @@ const createOrderHandler: CommandHandler<CreateOrderCommand, string> = async (
 const result = await createOrderHandler({
   type: "CreateOrder",
   customerId: "customer-123",
-  items: [{ productId: "product-1", quantity: 2 }],
+  items: [{ productId: "product-1", quantity: 2, price: 10.0 }],
 });
 
 if (result.ok) {
@@ -498,7 +525,7 @@ commandBus.register("CreateOrder", createOrderHandler);
 const busResult = await commandBus.execute({
   type: "CreateOrder",
   customerId: "customer-123",
-  items: [{ productId: "product-1", quantity: 2 }],
+  items: [{ productId: "product-1", quantity: 2, price: 10.0 }],
 });
 ```
 
@@ -568,7 +595,14 @@ const createOrderHandler: CommandHandler<CreateOrderCommand, string> = async (
   return await withCommit(
     { outbox, bus, uow },
     async () => {
-      const order = Order.create(cmd.customerId, cmd.items);
+      const orderId = `order-${Date.now()}` as OrderId;
+      const order = Order.create(orderId, cmd.customerId);
+
+      // Add items to the order
+      for (const item of cmd.items) {
+        order.addItem(item.productId, item.quantity, item.price);
+      }
+
       await repository.save(order);
 
       return {
@@ -606,7 +640,7 @@ import {
 type CreateOrderCommand = Command & {
   type: "CreateOrder";
   customerId: string;
-  items: OrderItem[];
+  items: Array<{ productId: string; quantity: number; price: number }>;
 };
 
 type GetOrderQuery = Query & {
@@ -618,7 +652,14 @@ type GetOrderQuery = Query & {
 const createOrderHandler: CommandHandler<CreateOrderCommand, OrderId> = async (
   cmd
 ) => {
-  const order = Order.create(cmd.customerId, cmd.items);
+  const orderId = `order-${Date.now()}` as OrderId;
+  const order = Order.create(orderId, cmd.customerId);
+
+  // Add items to the order
+  for (const item of cmd.items) {
+    order.addItem(item.productId, item.quantity, item.price);
+  }
+
   await repository.save(order);
   return ok(order.id);
 };

package/dist/deep-equal-except-C8yoSk4L.d.ts

@@ -0,0 +1,57 @@
+type Key = string | symbol;
+type PathSegment = string | number | symbol;
+interface DeepOmitOptions {
+    /**
+     * Keys to ignore everywhere in the object tree.
+     * Only applies to object properties, not Map/Set/TypedArray contents.
+     */
+    readonly ignoreKeys?: readonly Key[];
+    /**
+     * Fine-grained control: Key + path (without current key).
+     * Example path: ["user", "meta", 0, "data"]
+     */
+    readonly ignoreKeyPredicate?: (key: Key, path: readonly PathSegment[]) => boolean;
+}
+/**
+ * Creates a deep copy of `value` with certain keys removed according to the provided rules.
+ *
+ * This function recursively traverses the object tree and removes keys that match
+ * the criteria specified in `options`. Built-in types (Date, Map, Set, TypedArrays, etc.)
+ * are treated atomically and not modified.
+ *
+ * @param value - The value to create a deep copy from
+ * @param options - Options specifying which keys to ignore
+ * @returns A deep copy of `value` with specified keys removed
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: { c: 2, d: 3 } };
+ * const result = deepOmit(obj, { ignoreKeys: ['d'] });
+ * // result: { a: 1, b: { c: 2 } }
+ * ```
+ */
+declare function deepOmit<T>(value: T, options: DeepOmitOptions): T;
+
+type DeepEqualExceptOptions = DeepOmitOptions;
+/**
+ * Performs a deep equality comparison between two values after omitting specified keys.
+ *
+ * This function first removes the specified keys from both values using `deepOmit`,
+ * then performs a deep equality check using `deepEqual`.
+ *
+ * @param a - The first value to compare
+ * @param b - The second value to compare
+ * @param options - Options specifying which keys to omit before comparison
+ * @returns `true` if the values are deeply equal after omitting specified keys, `false` otherwise
+ *
+ * @example
+ * ```ts
+ * const obj1 = { id: 1, name: "Alice", updatedAt: "2024-01-01" };
+ * const obj2 = { id: 2, name: "Alice", updatedAt: "2024-01-02" };
+ *
+ * deepEqualExcept(obj1, obj2, { ignoreKeys: ["id", "updatedAt"] }); // true
+ * ```
+ */
+declare function deepEqualExcept(a: unknown, b: unknown, options: DeepEqualExceptOptions): boolean;
+
+export { type DeepOmitOptions as D, type Key as K, type PathSegment as P, type DeepEqualExceptOptions as a, deepEqualExcept as b, deepOmit as d };