JavaScriptモジュールエンティティパターン：ドメインオブジェクトモデリングの詳細

            
// Somewhere in an API controller or service...
async function createUser(req, res) {
  const { email, password, firstName, lastName } = req.body;

  // Business logic and validation is scattered here
  if (!email || !email.includes('@')) {
    return res.status(400).send({ error: 'A valid email is required.' });
  }

  if (!password || password.length < 8) {
    return res.status(400).send({ error: 'Password must be at least 8 characters.' });
  }

  const user = {
    email: email.toLowerCase(),
    password: await hashPassword(password), // Some utility function
    fullName: `${firstName} ${lastName}`, // Logic for derived data is here
    createdAt: new Date()
  };

  // Now, what is `user`? It's just a plain object.
  // Nothing stops another developer from doing this later:
  // user.email = 'an-invalid-email';
  // user.password = 'short';

  await db.users.insert(user);
  res.status(201).send(user);
}

            

              
                Copy
              
            
          

            
// file: /domain/user.js

export default function buildMakeUser() {
  // This inner function is the actual factory.
  // It has access to any dependencies passed to buildMakeUser, if needed.
  return function makeUser({
    id = generateId(), // Let's assume a function to generate a unique ID
    firstName,
    lastName,
    email,
    passwordHash,
    createdAt = new Date()
  }) {
    // ... validation and logic will go here ...

    const user = {
      getId: () => id,
      getFirstName: () => firstName,
      getLastName: () => lastName,
      getEmail: () => email,
      getPasswordHash: () => passwordHash,
      getCreatedAt: () => createdAt
    };

    // Using Object.freeze to make the object immutable.
    return Object.freeze(user);
  }
}

            

              
                Copy
              
            
          

            
// file: /domain/user.js

export default function buildMakeUser({ Id, isValidEmail, hashPassword }) {
  return function makeUser({
    id = Id.makeId(),
    firstName,
    lastName,
    email,
    password, // We now take a plain password and handle it inside
    createdAt = new Date()
  }) {
    if (!Id.isValidId(id)) {
      throw new Error('User must have a valid id.');
    }
    if (!firstName || firstName.length < 2) {
      throw new Error('First name must be at least 2 characters long.');
    }
    if (!lastName || lastName.length < 2) {
      throw new Error('Last name must be at least 2 characters long.');
    }
    if (!email || !isValidEmail(email)) {
      throw new Error('User must have a valid email address.');
    }
    if (!password || password.length < 8) {
      throw new Error('Password must be at least 8 characters long.');
    }

    // Data normalization and transformation happens here
    const passwordHash = hashPassword(password); 
    const normalizedEmail = email.toLowerCase();

    return Object.freeze({
      getId: () => id,
      getFirstName: () => firstName,
      getLastName: () => lastName,
      getEmail: () => normalizedEmail,
      getPasswordHash: () => passwordHash,
      getCreatedAt: () => createdAt
    });
  }
}

            

              
                Copy
              
            
          

            
// ... inside the makeUser function ...

    if (!password || password.length < 8) {
      // ...
    }

    const passwordHash = hashPassword(password);
    const normalizedEmail = email.toLowerCase();

    return Object.freeze({
      getId: () => id,
      getFirstName: () => firstName,
      getLastName: () => lastName,
      getEmail: () => normalizedEmail,
      getPasswordHash: () => passwordHash,
      getCreatedAt: () => createdAt,

      // Business Logic / Behavior
      getFullName: () => `${firstName} ${lastName}`,
      
      // A method that describes a business rule
      canVote: () => {
          // In some countries, voting age is 18. This is a business rule.
          // Let's assume we have a dateOfBirth property.
          const age = calculateAge(dateOfBirth);
          return age >= 18;
      }
    });
// ...

            

              
                Copy
              
            
          

            
// file: /domain/product.js

export default function buildMakeProduct({ Id }) {
  return function makeProduct({
    id = Id.makeId(),
    name,
    description,
    price,
    stock = 0
  }) {
    if (!Id.isValidId(id)) {
      throw new Error('Product must have a valid ID.');
    }
    if (!name || name.trim().length < 2) {
      throw new Error('Product name must be at least 2 characters.');
    }
    if (isNaN(price) || price <= 0) {
      throw new Error('Product must have a price greater than zero.');
    }
    if (isNaN(stock) || stock < 0) {
      throw new Error('Stock must be a non-negative number.');
    }

    return Object.freeze({
      getId: () => id,
      getName: () => name,
      getDescription: () => description,
      getPrice: () => price,
      getStock: () => stock,
      
      // Business logic
      isAvailable: () => stock > 0,
      
      // A method that modifies state by returning a new instance
      reduceStock: (amount) => {
        if (amount > stock) {
          throw new Error('Not enough stock available.');
        }
        // Return a NEW product object with the updated stock
        return makeProduct({ id, name, description, price, stock: stock - amount });
      }
    });
  }
}

            

              
                Copy
              
            
          

            
// file: /domain/order.js

export const ORDER_STATUS = {
  PENDING: 'PENDING',
  PAID: 'PAID',
  SHIPPED: 'SHIPPED',
  CANCELLED: 'CANCELLED'
};

export default function buildMakeOrder({ Id, validateOrderItem }) {
  return function makeOrder({
    id = Id.makeId(),
    customerId,
    items = [],
    status = ORDER_STATUS.PENDING,
    createdAt = new Date()
  }) {
    if (!Id.isValidId(id)) {
      throw new Error('Order must have a valid ID.');
    }
    if (!customerId) {
      throw new Error('Order must have a customer ID.');
    }

    let orderItems = [...items]; // Create a private copy to manage

    return Object.freeze({
      getId: () => id,
      getCustomerId: () => customerId,
      getItems: () => [...orderItems], // Return a copy to prevent external modification
      getStatus: () => status,
      getCreatedAt: () => createdAt,
      
      // Business Logic
      calculateTotal: () => {
        return orderItems.reduce((total, item) => {
          return total + (item.getPrice() * item.getQuantity());
        }, 0);
      },

      addItem: (item) => {
        // validateOrderItem is a function that ensures the item is a valid OrderItem entity
        validateOrderItem(item);

        // Business rule: prevent adding duplicates, just increase quantity
        const existingItemIndex = orderItems.findIndex(i => i.getProductId() === item.getProductId());

        if (existingItemIndex > -1) {
          const newQuantity = orderItems[existingItemIndex].getQuantity() + item.getQuantity();
          // Here you'd update the quantity on the existing item
          // (This requires items to be mutable or have an update method)
        } else {
          orderItems.push(item);
        }
      },

      markPaid: () => {
        if (status !== ORDER_STATUS.PENDING) {
          throw new Error('Only pending orders can be marked as paid.');
        }
        // Return a new Order instance with the updated status
        return makeOrder({ id, customerId, items: orderItems, status: ORDER_STATUS.PAID, createdAt });
      }
    });
  }
}

            

              
                Copy
              
            
          

            
// file: /use-cases/create-user.js

// This use case depends on the user entity factory and a database access function.
export default function makeCreateUser({ makeUser, usersDatabase }) {
  return async function createUser(userInfo) {
    // 1. Create a valid domain entity. This step validates the data.
    const user = makeUser(userInfo);

    // 2. Check for business rules that require external data (e.g., email uniqueness)
    const exists = await usersDatabase.findByEmail({ email: user.getEmail() });
    if (exists) {
      throw new Error('Email address is already in use.');
    }

    // 3. Persist the entity. The database needs a plain object.
    const persisted = await usersDatabase.insert({
      id: user.getId(),
      firstName: user.getFirstName(),
      // ... and so on
    });

    return persisted;
  }
}

            

              
                Copy
              
            
          

            
// ... inside the makeUser function ...

    return Object.freeze({
      getId: () => id,
      // ... other getters

      // Serialization method
      toObject: () => ({
        id,
        firstName,
        lastName,
        email: normalizedEmail,
        createdAt
        // Notice we don't include the passwordHash
      })
    });

            

              
                Copy
              
            
          

            
// file: /domain/user.ts

// Define the entity's public interface
export type User = Readonly<{
  getId: () => string;
  getFirstName: () => string;
  // ... etc
  getFullName: () => string;
}>;

// The factory function now returns the User type
export default function buildMakeUser(...) {
  return function makeUser(...): User {
    // ... implementation
  }
}

            

              
                Copy