Agregate root with entities

[issamwahbi]

Hello,

Thank you for this great repo. Is the best.
I have a question regarding how to manage the use case when the agregate root has entities. It seems to me that the persistance layer is not capable of handle this case.
As an exemple I have an Employee Agregate root with props. One of them is vehicules. The vehicules, is an array of VehiculeEntity.
The VehiculeEntity must be saved in the DB along with the Agregate root in a dedicated table. I have created a dedicated Zod schema for the Vehicule entity. But I cannot find an easy solution to save the VehiculeEntity without violating DDD principales.

Thanks you for you help.

[Sairyss]

Not sure why you need to put Vehicles into an Employee, for me it looks like two entirely different domains. I would separate them and just put employeeId into a VehicleEntity and keep them separate.

As for saving it, you just start a transaction and save everything, something like this:

await this.repo.transaction(async () => {
  await this.repo.insert(employee);
  await this.repo.insert(vehicles);
})

If you still want to have Vehicles inside Employee for some reason, you can create a dedicated method for saving it:

await this.repo.saveEmployee(employee);

And repository will save things into separate tables:

async saveEmployee(employee: Employee): Promise<void> {
  await this.transaction(() => {
    await this.writeQuery(sql`INSERT INTO employee (name, ... ) VALUES (${employee.name}, ... )`);
    await this.writeQuery(sql`INSERT INTO vehicles VALUES (employee_id, name, ... )  (${employee.id}, ${employee.vehicle.name}, ... )`); // <- you may need use map here to insert all vehicles
  })
}

[issamwahbi]

Hello,

Thank you for the answer.
Indeed I need to have vehicles inside of Employee. Because it is the same bounded context. The vehicles cannot exist without and employee
Since I am using the SqlRepositoryBase as a unique repository for all my application. I cannot have the saveEmployee. Otherwise I will need to create a dedicated repository for each Aggregate root with child entities. Maily I have 3 use cases:

• The aggregate root doesn't has child entities. The SqlRepositoryBase can be used as is
• The aggregate root has child entities following the same cycle as the aggregate root. For example we create the entities in the same transaction when we create the aggregate root
• The aggregate root has child entities that doesn't follow the same cycle. For example we create the Aggregate root without the entity and then we receive a command to create the entity. In my example, the front-end is sending me a create employee command without the employee vehicle. Then I receive later on a new command to add a new vehicle to the aggregate

I manage to do generic CRUD operations for the 2 first cases. The third one is very tricky.

For the SELECTs I did something like this:

  async findAllPaginated(
    params: PaginatedQueryParams,
  ): Promise<Paginated<Aggregate>> {
    const nestedModelsQuery = this.generateNestedModelsSelectQuery();

    const query = sql.type(this.schema)`
    SELECT ${sql.identifier([this.tableName])}.*,
    ${nestedModelsQuery}
    FROM ${sql.identifier([this.tableName])}
    LIMIT ${params.limit}
    OFFSET ${params.offset}
    `;

    const pool = await this.createSlonikPool(); // I don't inject the pool because I am in multi tenant application...
    const result = await pool.query(query);

    const entities = result.rows.map(this.mapper.toDomain);
    return new Paginated({
      data: entities,
      count: result.rowCount,
      limit: params.limit,
      page: params.page,
    });
  }

  private getNestedModelsNames(): string[] {
    const nestedObjectNames: string[] = [];

    const processField = (fieldSchema: z.Schema<any>, fieldName: string) => {
      let schema = fieldSchema;
      // Check for optional() and nullable() modifiers
      let isOptional = false;
      let isNullable = false;

      while (schema instanceof ZodOptional || schema instanceof ZodNullable) {
        if (schema instanceof ZodOptional) {
          isOptional = true;
          schema = schema._def.innerType;
        } else if (schema instanceof ZodNullable) {
          isNullable = true;
          schema = schema._def.innerType;
        }
      }
      if (schema instanceof ZodObject) {
        nestedObjectNames.push(fieldName);
      } else if (
        schema instanceof ZodArray &&
        schema.element instanceof ZodObject
      ) {
        nestedObjectNames.push(fieldName);
      }
    };

    for (const field in this.schema.shape) {
      const fieldSchema = this.schema.shape[field];
      processField(fieldSchema, field);
    }

    Logger.debug(`getNestedModelsNames: ${nestedObjectNames}`);

    return nestedObjectNames;
  }

 private generateNestedModelsSelectQuery() {
    const nestedModelsNames = this.getNestedModelsNames();
    if (nestedModelsNames.length === 0) return '';
    const selectQueries = nestedModelsNames.map((nestedObjectName) => {
      const joinCondition = sql`${sql.identifier([
        nestedObjectName,
      ])}.${sql.identifier([this.relationshipId])} = ${sql.identifier([
        this.tableName,
      ])}."id"`;
      return sql`(SELECT json_agg(${sql.identifier([
        nestedObjectName,
      ])}) FROM ${sql.identifier([
        nestedObjectName,
      ])} WHERE ${joinCondition}) as ${sql.identifier([nestedObjectName])} `;
    });

    const nestedObjectQuery = selectQueries[0]; // TO DO manage the case when the Aggregate has multiple nested entities

    return nestedObjectQuery;
  }

For the INSERT and UPDATE when the entities are created or updated with the aggregate root, I did something like this:

async insert(entity: Aggregate | Aggregate[]): Promise<void> {
    const entities = Array.isArray(entity) ? entity : [entity];

    const records = entities.map(this.mapper.toPersistence);

    const { agregateRootModelRecords, nestedModelsRecords } =
      this.generateModelsRecords(records);

    const aggregateQuery = this.generateInsertQuery(agregateRootModelRecords);

    try {
      if (nestedModelsRecords.length > 0) {
        const nestedModelsQuery = this.generateInsertQuery(nestedModelsRecords);
        await this.transaction(async () => {
          // the aggregate Query must be created first otherwise the foreigh key constraint will fail
          await this.writeQuery(aggregateQuery, entities);
          await this.writeQuery(nestedModelsQuery, entities);
        });
      } else {
        await this.writeQuery(aggregateQuery, entities);
      }
    } catch (error) {
      if (error instanceof UniqueIntegrityConstraintViolationError) {
        this.logger.debug(
          `[${RequestContextService.getRequestId()}] ${
            (error.originalError as any).detail
          }`,
        );
        throw new ConflictException('Record already exists', error);
      }
      throw error;
    }
  }

private generateModelsRecords(records: DbModel[]) {
    let agregateRootModelRecords: DbModel[] = [];
    let nestedModelsRecords: DbModel[] = [];

    //remove nested object from the records and create a new records to be inserted
    // call the generateInsertQuery on aggregate record
    // call the generateInsertQuery on the nested entity records if any
    const nestedModelsNames = this.getNestedModelsNames(); // return string[] as ["vehicles"]
    // keep the agregate root model records as an array for compatibility with the generateInsertQuery method
    if (nestedModelsNames.length > 0) {
      agregateRootModelRecords = records.map((record) => {
        // deleteAttributesFromObject is returing a new object withou the nested models
        const aggregateModelRecord = this.deleteAttributesFromObject(
          record,
          nestedModelsNames,
        );
        Logger.debug(`aggregateModelRecord: ${aggregateModelRecord}`);
        return aggregateModelRecord;
      });
      nestedModelsRecords = nestedModelsNames
        .map((nestedModelsName) => {
          return record[nestedModelsName];
        })
        .filter(
          (nestedModelsRecord) =>
            nestedModelsRecord !== null && nestedModelsRecord !== undefined,
        );
    } else {
      // if no nested models are found, the agregate root model records are the same as the records
      agregateRootModelRecords = records;
    }

    return { agregateRootModelRecords, nestedModelsRecords };
  }

  private deleteAttributesFromObject(object: DbModel, attributes: string[]) {
    const objectWithoutAttributes = { ...object };
    attributes.forEach((attribute) => {
      delete objectWithoutAttributes[attribute];
    });
    return objectWithoutAttributes;
  }

Maybe it's over engineering, but I have 30 aggregate roots and each of them has between 0 and 3 entities.

[Sairyss]

Indeed I need to have vehicles inside of Employee. Because it is the same bounded context. The vehicles cannot exist without and employee

Maybe in your case it makes sense to have it like that, but just to clarify things:
the fact that vehicles cannot exist without an employee not necessary means it has to be part of the same aggregate root. Your employees can also have a Manager, a Wallet, a Department they belong to, and a bunch of other relations that cannot exist one without the other. But it doesn't mean that you have to put all of the above into the same aggregate root.

Since I am using the SqlRepositoryBase as a unique repository for all my application. I cannot have the saveEmployee.

You can tweak your repository and a mapper a little so the mapper produces an array of entities it needs to save. For example an employee mapper can return something like this: [employee, ...vehicles[] ]. And repository just maps all of it into multiple statements like insert into employees ... values (...) and insert into vehicles ... values ($1,$2,$3), ($4,$5,$6), (...).

If you want to make things that generic you might consider using an ORM that handles this for you, most ORMs let you insert multiple entities like that out of the box. Using an ORM just to automate migrations and bulk inserts is totally fine IMO, makes life easier.

Also, if you have a unique repository for the entire app, how do you handle updates? if, for example, you only need to update an address of an employee? If you do upserts all the time keep in mind that it can affect performance.

The third one is very tricky.

The third one is not a very good approach IMO. You should be able to save a bunch of entities in a single transaction. Just tweak your repository/mapper a little to adapt to your needs.