@labdigital/commercetools-mock 1.8.1 → 1.9.0

package/dist/index.cjs

@@ -1588,6 +1588,71 @@ var getRepositoryContext = (request) => ({
   projectKey: request.params.projectKey,
   storeKey: request.params.storeKey
 });
+var createAssociate = (a, projectKey, storage) => {
+  if (!a)
+    return void 0;
+  if (!a.associateRoleAssignments) {
+    throw new Error("AssociateRoleAssignments is required");
+  }
+  return {
+    customer: getReferenceFromResourceIdentifier(
+      a.customer,
+      projectKey,
+      storage
+    ),
+    associateRoleAssignments: a.associateRoleAssignments?.map(
+      (a2) => ({
+        associateRole: getAssociateRoleKeyReference(
+          a2.associateRole,
+          projectKey,
+          storage
+        ),
+        inheritance: a2.inheritance
+      })
+    ),
+    roles: a.roles
+  };
+};
+var getAssociateRoleKeyReference = (id, projectKey, storage) => {
+  if (id.key) {
+    return {
+      typeId: "associate-role",
+      key: id.key
+    };
+  }
+  const value = getReferenceFromResourceIdentifier(
+    id,
+    projectKey,
+    storage
+  );
+  if (!value.obj?.key) {
+    throw new Error("No associate-role found for reference");
+  }
+  return {
+    typeId: "associate-role",
+    key: value.obj?.key
+  };
+};
+var getBusinessUnitKeyReference = (id, projectKey, storage) => {
+  if (id.key) {
+    return {
+      typeId: "business-unit",
+      key: id.key
+    };
+  }
+  const value = getReferenceFromResourceIdentifier(
+    id,
+    projectKey,
+    storage
+  );
+  if (!value.obj?.key) {
+    throw new Error("No business-unit found for reference");
+  }
+  return {
+    typeId: "business-unit",
+    key: value.obj?.key
+  };
+};
 
 // src/services/project.ts
 var ProjectService = class {
@@ -1847,9 +1912,128 @@ var BusinessUnitRepository = class extends AbstractResourceRepository {
   getTypeId() {
     return "business-unit";
   }
+  _isCompanyDraft(draft) {
+    return draft.unitType === "Company";
+  }
+  _isDivisionDraft(draft) {
+    return draft.unitType === "Division";
+  }
   create(context, draft) {
-    throw new Error("Method not implemented.");
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      status: draft.status,
+      stores: draft.stores?.map(
+        (s) => getStoreKeyReference(s, context.projectKey, this._storage)
+      ),
+      storeMode: draft.storeMode,
+      name: draft.name,
+      contactEmail: draft.contactEmail,
+      addresses: draft.addresses?.map(
+        (a) => createAddress(a, context.projectKey, this._storage)
+      ),
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
+      shippingAddressIds: draft.shippingAddresses,
+      defaultShippingAddressId: draft.defaultShippingAddress,
+      billingAddressIds: draft.billingAddresses,
+      associateMode: draft.associateMode,
+      associates: draft.associates?.map(
+        (a) => createAssociate(a, context.projectKey, this._storage)
+      )
+    };
+    if (this._isDivisionDraft(draft)) {
+      const division = {
+        ...resource,
+        parentUnit: getBusinessUnitKeyReference(
+          draft.parentUnit,
+          context.projectKey,
+          this._storage
+        )
+      };
+      this.saveNew(context, division);
+      return division;
+    } else if (this._isCompanyDraft(draft)) {
+      const company = resource;
+      this.saveNew(context, company);
+      return company;
+    }
+    throw new Error("Invalid business unit type");
   }
+  actions = {
+    addAddress: (context, resource, { address }) => {
+      const newAddress = createAddress(
+        address,
+        context.projectKey,
+        this._storage
+      );
+      if (newAddress) {
+        resource.addresses.push(newAddress);
+      }
+    },
+    addAssociate: (context, resource, { associate }) => {
+      const newAssociate = createAssociate(
+        associate,
+        context.projectKey,
+        this._storage
+      );
+      if (newAssociate) {
+        resource.associates.push(newAssociate);
+      }
+    },
+    setAssociates: (context, resource, { associates }) => {
+      const newAssociates = associates.map((a) => createAssociate(a, context.projectKey, this._storage)).filter((a) => a !== void 0);
+      resource.associates = newAssociates || void 0;
+    },
+    setContactEmail: (context, resource, { contactEmail }) => {
+      resource.contactEmail = contactEmail;
+    },
+    setStoreMode: (context, resource, { storeMode }) => {
+      resource.storeMode = storeMode;
+    },
+    changeAssociateMode: (context, resource, { storeMode }) => {
+      resource.associateMode = storeMode;
+    },
+    changeName: (context, resource, { name }) => {
+      resource.name = name;
+    },
+    changeAddress: (context, resource, { address }) => {
+      const newAddress = createAddress(
+        address,
+        context.projectKey,
+        this._storage
+      );
+      if (newAddress) {
+        resource.addresses.push(newAddress);
+      }
+    },
+    addStore: (context, resource, { store }) => {
+      const newStore = getStoreKeyReference(
+        store,
+        context.projectKey,
+        this._storage
+      );
+      if (newStore) {
+        if (!resource.stores) {
+          resource.stores = [];
+        }
+        resource.stores.push(newStore);
+      }
+    },
+    changeParentUnit: (context, resource, { parentUnit }) => {
+      resource.parentUnit = getBusinessUnitKeyReference(
+        parentUnit,
+        context.projectKey,
+        this._storage
+      );
+    },
+    changeStatus: (context, resource, { status }) => {
+      resource.status = status;
+    }
+  };
 };
 
 // src/repositories/cart.ts
@@ -2337,6 +2521,26 @@ var CartDiscountRepository = class extends AbstractResourceRepository {
       } else {
         resource.custom.fields[name] = value;
       }
+    },
+    setCustomType: (context, resource, { type, fields }) => {
+      if (!type) {
+        resource.custom = void 0;
+      } else {
+        const resolvedType = this._storage.getByResourceIdentifier(
+          context.projectKey,
+          type
+        );
+        if (!resolvedType) {
+          throw new Error(`Type ${type} not found`);
+        }
+        resource.custom = {
+          type: {
+            typeId: "type",
+            id: resolvedType.id
+          },
+          fields: fields || {}
+        };
+      }
     }
   };
 };
@@ -5477,6 +5681,18 @@ var AssociateRoleServices = class extends AbstractService {
   }
 };
 
+// src/services/business-units.ts
+var BusinessUnitServices = class extends AbstractService {
+  repository;
+  constructor(parent, repository) {
+    super(parent);
+    this.repository = repository;
+  }
+  getBasePath() {
+    return "business-units";
+  }
+};
+
 // src/services/cart.ts
 var CartService = class extends AbstractService {
   repository;
@@ -6067,6 +6283,7 @@ var AttributeGroupService = class extends AbstractService {
 // src/services/index.ts
 var createServices = (router, repos) => ({
   "associate-role": new AssociateRoleServices(router, repos["associate-role"]),
+  "business-unit": new BusinessUnitServices(router, repos["business-unit"]),
   category: new CategoryServices(router, repos["category"]),
   cart: new CartService(router, repos["cart"], repos["order"]),
   "cart-discount": new CartDiscountService(router, repos["cart-discount"]),