@reactionary/commercetools 0.6.5 → 0.6.7

package/capabilities/employee.capability.js

@@ -0,0 +1,346 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  EmployeeCapability,
+  EmployeeMutationAssignRoleSchema,
+  EmployeeMutationUnassignRoleSchema,
+  EmployeeQueryByEmailSchema,
+  EmployeeQueryListSchema,
+  error,
+  EmployeePaginatedListSchema,
+  EmployeeSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import {} from "../factories/employee/employee.factory.js";
+class CommercetoolsEmployeeCapability extends EmployeeCapability {
+  config;
+  commercetools;
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getClient() {
+    const client = await this.commercetools.getAdminClient();
+    if (this.context.session.identityContext.identity.type !== "Registered") {
+      throw new Error("Only registered users can access employees capabilities");
+    }
+    return client.withProjectKey({ projectKey: this.config.projectKey }).asAssociate().withAssociateIdValue({
+      associateId: this.context.session.identityContext.identity.id.userId
+    });
+  }
+  async getAdminClient() {
+    const client = await this.commercetools.getAdminClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
+  }
+  async getBusinessUnit(key, extraExpands = []) {
+    const client = await this.getClient();
+    const response = await client.businessUnits().withKey({ key }).get({
+      queryArgs: {
+        expand: ["associates[*].customer", ...extraExpands]
+      }
+    }).execute().catch((err) => {
+      if (err.statusCode === 404) {
+        return null;
+      }
+      throw err;
+    });
+    return response ? response.body : null;
+  }
+  async updateBusinessUnit(key, version, actions) {
+    const client = await this.getClient();
+    const response = await client.businessUnits().withKey({ key }).post({
+      body: {
+        version,
+        actions
+      },
+      queryArgs: {
+        expand: ["associates[*].customer"]
+      }
+    }).execute();
+    return response.body;
+  }
+  getAssociateRole(associate) {
+    return associate.associateRoleAssignments[0]?.associateRole.key;
+  }
+  getRoles(associate) {
+    return associate.associateRoleAssignments.map(
+      (assignment) => assignment.associateRole.key
+    );
+  }
+  findAssociateByCustomerId(businessUnit, customerId) {
+    return businessUnit.associates.find(
+      (associate) => associate.customer.id === customerId
+    );
+  }
+  findAssociateByEmail(businessUnit, email) {
+    return businessUnit.associates.find(
+      (associate) => associate.customer.obj?.email === email
+    );
+  }
+  async listEmployees(payload) {
+    const businessUnit = await this.getBusinessUnit(payload.search.company.taxIdentifier);
+    if (!businessUnit) {
+      return success(
+        this.factory.parseEmployeePaginatedList(
+          this.context,
+          {
+            items: [],
+            totalCount: 0
+          },
+          payload
+        )
+      );
+    }
+    const employees = businessUnit.associates.filter((associate) => {
+      const assocEmail = (associate.customer.obj?.email ?? "").toLowerCase();
+      const assocFirstName = (associate.customer.obj?.firstName ?? "").toLowerCase();
+      const assocLastName = (associate.customer.obj?.lastName ?? "").toLowerCase();
+      const assocRole = this.getAssociateRole(associate) ?? "";
+      if (payload.search.email && !assocEmail.startsWith(payload.search.email.toLowerCase())) {
+        return false;
+      }
+      if (payload.search.firstName && !assocFirstName.startsWith(payload.search.firstName.toLowerCase())) {
+        return false;
+      }
+      if (payload.search.lastName && !assocLastName.startsWith(payload.search.lastName.toLowerCase())) {
+        return false;
+      }
+      if (payload.search.role && assocRole !== this.factory.mapRole(payload.search.role)) {
+        return false;
+      }
+      return true;
+    });
+    const pageNumber = payload.search.paginationOptions.pageNumber;
+    const pageSize = payload.search.paginationOptions.pageSize;
+    const offset = (pageNumber - 1) * pageSize;
+    const paged = employees.slice(offset, offset + pageSize);
+    return success(
+      this.factory.parseEmployeePaginatedList(
+        this.context,
+        {
+          items: paged,
+          totalCount: employees.length
+        },
+        payload
+      )
+    );
+  }
+  async getByEmail(payload) {
+    const businessUnit = await this.getBusinessUnit(payload.company.taxIdentifier);
+    if (!businessUnit) {
+      return error({
+        type: "NotFound",
+        identifier: payload.company
+      });
+    }
+    const customer = await this.findAssociateByEmail(businessUnit, payload.email);
+    if (!customer) {
+      return error({
+        type: "NotFound",
+        identifier: { email: payload.email }
+      });
+    }
+    return success(this.factory.parseEmployee(this.context, {
+      company: payload.company,
+      associate: customer
+    }));
+  }
+  assignRolePayload(payload) {
+    const nextRoles = Array.from(/* @__PURE__ */ new Set([this.factory.mapRole(payload.role)]));
+    return [
+      {
+        action: "changeAssociate",
+        associate: {
+          customer: {
+            typeId: "customer",
+            id: payload.employeeIdentifier.userId
+          },
+          associateRoleAssignments: nextRoles.map((roleKey) => ({
+            associateRole: {
+              typeId: "associate-role",
+              key: roleKey
+            }
+          }))
+        }
+      }
+    ];
+  }
+  async assignRole(payload) {
+    const key = payload.company.taxIdentifier;
+    const businessUnit = await this.getBusinessUnit(key);
+    if (!businessUnit) {
+      return error({
+        type: "NotFound",
+        identifier: payload.company
+      });
+    }
+    const associate = this.findAssociateByCustomerId(
+      businessUnit,
+      payload.employeeIdentifier.userId
+    );
+    if (!associate) {
+      return error({
+        type: "NotFound",
+        identifier: payload.employeeIdentifier
+      });
+    }
+    const actions = this.assignRolePayload(payload);
+    const updated = await this.updateBusinessUnit(key, businessUnit.version, actions);
+    const updatedAssociate = this.findAssociateByCustomerId(
+      updated,
+      payload.employeeIdentifier.userId
+    );
+    if (!updatedAssociate) {
+      return error({
+        type: "NotFound",
+        identifier: payload.employeeIdentifier
+      });
+    }
+    const customersById = this.findAssociateByCustomerId(updated, payload.employeeIdentifier.userId);
+    if (!customersById) {
+      return error({
+        type: "NotFound",
+        identifier: payload.employeeIdentifier
+      });
+    }
+    return success(this.factory.parseEmployee(this.context, { company: payload.company, associate: customersById }));
+  }
+  /**
+   * The CT role assigned when you have no other roles in the org
+   * @returns
+   */
+  getDefaultRole() {
+    return "buyer";
+  }
+  unassignRolePayload(payload, associate) {
+    const ctRole = this.factory.mapRole(payload.role);
+    const nextRoles = this.getRoles(associate).filter((role) => role !== ctRole);
+    if (nextRoles.length === 0) {
+      nextRoles.push(this.getDefaultRole());
+    }
+    return [
+      {
+        action: "changeAssociate",
+        associate: {
+          customer: {
+            typeId: "customer",
+            id: payload.employeeIdentifier.userId
+          },
+          associateRoleAssignments: nextRoles.map((roleKey) => ({
+            associateRole: {
+              typeId: "associate-role",
+              key: roleKey
+            }
+          }))
+        }
+      }
+    ];
+  }
+  async unassignRole(payload) {
+    const key = payload.company.taxIdentifier;
+    const businessUnit = await this.getBusinessUnit(key);
+    if (!businessUnit) {
+      return error({
+        type: "NotFound",
+        identifier: payload.company
+      });
+    }
+    const associate = this.findAssociateByCustomerId(
+      businessUnit,
+      payload.employeeIdentifier.userId
+    );
+    if (!associate) {
+      return error({
+        type: "NotFound",
+        identifier: payload.employeeIdentifier
+      });
+    }
+    const actions = this.unassignRolePayload(payload, associate);
+    const updated = await this.updateBusinessUnit(key, businessUnit.version, actions);
+    const updatedAssociate = this.findAssociateByCustomerId(
+      updated,
+      payload.employeeIdentifier.userId
+    );
+    if (!updatedAssociate) {
+      return error({
+        type: "NotFound",
+        identifier: payload.employeeIdentifier
+      });
+    }
+    return success(this.factory.parseEmployee(this.context, { company: payload.company, associate: updatedAssociate }));
+  }
+  removeEmployeePayload(payload) {
+    return [
+      {
+        action: "removeAssociate",
+        customer: {
+          typeId: "customer",
+          id: payload.employeeIdentifier.userId
+        }
+      }
+    ];
+  }
+  async removeEmployee(payload) {
+    const key = payload.company.taxIdentifier;
+    const businessUnit = await this.getBusinessUnit(key);
+    if (!businessUnit) {
+      return error({
+        type: "NotFound",
+        identifier: payload.company
+      });
+    }
+    const associate = this.findAssociateByCustomerId(
+      businessUnit,
+      payload.employeeIdentifier.userId
+    );
+    if (!associate) {
+      return error({
+        type: "NotFound",
+        identifier: payload.employeeIdentifier
+      });
+    }
+    const actions = this.removeEmployeePayload(payload);
+    await this.updateBusinessUnit(key, businessUnit.version, actions);
+    return success(void 0);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeQueryListSchema,
+    outputSchema: EmployeePaginatedListSchema
+  })
+], CommercetoolsEmployeeCapability.prototype, "listEmployees", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeQueryByEmailSchema,
+    outputSchema: EmployeeSchema
+  })
+], CommercetoolsEmployeeCapability.prototype, "getByEmail", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeMutationAssignRoleSchema,
+    outputSchema: EmployeeSchema
+  })
+], CommercetoolsEmployeeCapability.prototype, "assignRole", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeMutationUnassignRoleSchema,
+    outputSchema: EmployeeSchema
+  })
+], CommercetoolsEmployeeCapability.prototype, "unassignRole", 1);
+export {
+  CommercetoolsEmployeeCapability
+};

package/capabilities/index.js

@@ -13,3 +13,6 @@ export * from "./product-search.capability.js";
 export * from "./store.capability.js";
 export * from "./order.capability.js";
 export * from "./checkout.capability.js";
+export * from "./company-registration.capability.js";
+export * from "./company.capability.js";
+export * from "./employee.capability.js";

package/capabilities/profile.capability.js

@@ -214,6 +214,16 @@ class CommercetoolsProfileCapability extends ProfileCapability {
         address: this.createCTAddressDraft(payload.address)
       });
     }
+    updateActions.push(
+      {
+        action: "setFirstName",
+        firstName: payload.address.firstName
+      },
+      {
+        action: "setLastName",
+        lastName: payload.address.lastName
+      }
+    );
     if (updateActions.length > 0) {
       const updateResponse = await client.me().post({
         body: {

package/core/capability-descriptors.js

@@ -4,6 +4,10 @@ import {
   CategoryPaginatedResultSchema,
   CategorySchema,
   CheckoutSchema,
+  CompanySchema,
+  CompanyPaginatedListSchema,
+  EmployeeSchema,
+  EmployeePaginatedListSchema,
   IdentitySchema,
   InventorySchema,
   OrderSearchResultSchema,
@@ -41,6 +45,7 @@ import { CommercetoolsProductReviewsFactory } from "../factories/product-reviews
 import { CommercetoolsProductSearchFactory } from "../factories/product-search/product-search.factory.js";
 import { CommercetoolsProfileFactory } from "../factories/profile/profile.factory.js";
 import { CommercetoolsStoreFactory } from "../factories/store/store.factory.js";
+import { CommercetoolsCompanyRegistrationFactory } from "../factories/company-registration/company-registration.factory.js";
 import { CommercetoolsCartCapability } from "../capabilities/cart.capability.js";
 import { CommercetoolsCategoryCapability } from "../capabilities/category.capability.js";
 import { CommercetoolsCheckoutCapability } from "../capabilities/checkout.capability.js";
@@ -56,6 +61,13 @@ import { CommercetoolsProductReviewsCapability } from "../capabilities/product-r
 import { CommercetoolsProductSearchCapability } from "../capabilities/product-search.capability.js";
 import { CommercetoolsProfileCapability } from "../capabilities/profile.capability.js";
 import { CommercetoolsStoreCapability } from "../capabilities/store.capability.js";
+import { CommercetoolsCompanyRegistrationCapability } from "../capabilities/company-registration.capability.js";
+import { CommercetoolsCompanyCapability } from "../capabilities/company.capability.js";
+import { CommercetoolsCompanyFactory } from "../factories/company/company.factory.js";
+import { CommercetoolsEmployeeFactory } from "../factories/employee/employee.factory.js";
+import { CommercetoolsEmployeeCapability } from "../capabilities/employee.capability.js";
+import { CommercetoolsEmployeeInvitationCapability } from "../capabilities/employee-invitation.capability.js";
+import { CommercetoolsEmployeeInvitationFactory } from "../factories/employee-invitation/employee-invitation.factory.js";
 const capabilityKeys = [
   "product",
   "profile",
@@ -71,7 +83,11 @@ const capabilityKeys = [
   "checkout",
   "store",
   "order",
-  "orderSearch"
+  "orderSearch",
+  "companyRegistration",
+  "company",
+  "employee",
+  "employeeInvitation"
 ];
 const capabilityDescriptors = {
   product: {
@@ -266,6 +282,54 @@ const capabilityDescriptors = {
       args.commercetoolsApi,
       args.factory
     )
+  },
+  companyRegistration: {
+    isEnabled: (caps) => caps.companyRegistration?.enabled,
+    getOverride: (caps) => caps.companyRegistration,
+    createDefaultFactory: () => new CommercetoolsCompanyRegistrationFactory(),
+    createDefaultCapability: (args) => new CommercetoolsCompanyRegistrationCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  company: {
+    isEnabled: (caps) => caps.company?.enabled,
+    getOverride: (caps) => caps.company,
+    createDefaultFactory: () => new CommercetoolsCompanyFactory(CompanySchema, CompanyPaginatedListSchema),
+    createDefaultCapability: (args) => new CommercetoolsCompanyCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  employee: {
+    isEnabled: (caps) => caps.employee?.enabled,
+    getOverride: (caps) => caps.employee,
+    createDefaultFactory: () => new CommercetoolsEmployeeFactory(EmployeeSchema, EmployeePaginatedListSchema),
+    createDefaultCapability: (args) => new CommercetoolsEmployeeCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
+  },
+  employeeInvitation: {
+    isEnabled: (caps) => caps.employeeInvitation?.enabled,
+    getOverride: (caps) => caps.employeeInvitation,
+    createDefaultFactory: () => new CommercetoolsEmployeeInvitationFactory(),
+    createDefaultCapability: (args) => new CommercetoolsEmployeeInvitationCapability(
+      args.config,
+      args.cache,
+      args.context,
+      args.commercetoolsApi,
+      args.factory
+    )
   }
 };
 export {

package/core/client.js

@@ -111,8 +111,8 @@ class CommercetoolsAPI {
     let builder = this.createBaseClientBuilder();
     builder = builder.withAnonymousSessionFlow({
       credentials: {
-        clientId: this.config.clientId,
-        clientSecret: this.config.clientSecret
+        clientId: this.config.adminClientId || this.config.clientId,
+        clientSecret: this.config.adminClientSecret || this.config.clientSecret
       },
       host: this.config.authUrl,
       projectKey: this.config.projectKey

package/factories/checkout/checkout.factory.js

@@ -70,6 +70,10 @@ class CommercetoolsCheckoutFactory {
     for (const lineItem of data.lineItems) {
       items.push(this.parseCheckoutItem(lineItem));
     }
+    const pointOfContact = {
+      email: data.billingAddress?.email || "",
+      phone: data.billingAddress?.phone
+    };
     const shippingInstruction = this.parseShippingInstruction(data);
     const readyForFinalization = this.isReadyForFinalization(
       price,
@@ -89,7 +93,8 @@ class CommercetoolsCheckoutFactory {
       shippingInstruction,
       paymentInstructions,
       items,
-      price
+      price,
+      pointOfContact
     };
     return this.checkoutSchema.parse(result);
   }

package/factories/company/company.factory.js

@@ -0,0 +1,80 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsCompanyFactory {
+  companySchema;
+  companyPaginatedListSchema;
+  constructor(companySchema, companyPaginatedListSchema) {
+    this.companySchema = companySchema;
+    this.companyPaginatedListSchema = companyPaginatedListSchema;
+  }
+  parseCompanyPaginatedList(context, data, payload) {
+    const result = {
+      pageNumber: payload.search.paginationOptions.pageNumber,
+      pageSize: payload.search.paginationOptions.pageSize,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total || 0) / payload.search.paginationOptions.pageSize),
+      items: data.results.map((bu) => this.parseCompany(context, bu)),
+      identifier: payload.search
+    };
+    return this.companyPaginatedListSchema.parse(result);
+  }
+  parseCompany(_context, data) {
+    const defaultShippingAddress = data.defaultShippingAddressId ? data.addresses.find((addr) => addr.id === data.defaultShippingAddressId) : void 0;
+    const defaultBillingAddress = data.defaultBillingAddressId ? data.addresses.find((addr) => addr.id === data.defaultBillingAddressId) : void 0;
+    const alternateShippingAddresses = data.addresses.filter((addr) => addr.id !== data.defaultShippingAddressId).filter((addr) => addr.id !== data.defaultBillingAddressId).map((addr) => this.parseAddress(addr));
+    const customFields = data.custom?.fields;
+    const result = {
+      identifier: {
+        taxIdentifier: data.key
+      },
+      name: data.name,
+      dunsIdentifier: customFields?.["dunsIdentifier"],
+      tinIdentifier: customFields?.["tinIdentifier"],
+      status: this.mapBusinessUnitStatus(data.status),
+      pointOfContact: {
+        email: data.contactEmail ?? "",
+        phone: customFields?.["pointOfContactPhone"]
+      },
+      shippingAddress: defaultShippingAddress ? this.parseAddress(defaultShippingAddress) : void 0,
+      billingAddress: defaultBillingAddress ? this.parseAddress(defaultBillingAddress) : {
+        identifier: { nickName: "" },
+        firstName: "",
+        lastName: "",
+        streetAddress: "",
+        streetNumber: "",
+        city: "",
+        region: "",
+        postalCode: "",
+        countryCode: ""
+      },
+      alternateShippingAddresses,
+      isCustomAddressesAllowed: customFields?.["isCustomAddressesAllowed"] ?? false,
+      isSelfManagementOfShippingAddressesAllowed: customFields?.["isSelfManagementOfShippingAddressesAllowed"] ?? true
+    };
+    return this.companySchema.parse(result);
+  }
+  mapBusinessUnitStatus(status) {
+    switch (status) {
+      case "Active":
+        return "active";
+      default:
+        return "blocked";
+    }
+  }
+  parseAddress(address) {
+    return {
+      identifier: { nickName: address.key || "" },
+      firstName: address.firstName || "",
+      lastName: address.lastName || "",
+      streetAddress: address.streetName || "",
+      streetNumber: address.streetNumber || "",
+      city: address.city || "",
+      region: address.region || "",
+      postalCode: address.postalCode || "",
+      countryCode: address.country
+    };
+  }
+}
+export {
+  CommercetoolsCompanyFactory
+};

package/factories/company-registration/company-registration.factory.js

@@ -0,0 +1,36 @@
+import {
+  CompanyRegistrationRequestSchema
+} from "@reactionary/core";
+class CommercetoolsCompanyRegistrationFactory {
+  companyRegistrationRequestSchema = CompanyRegistrationRequestSchema;
+  parseCompanyRegistrationRequest(_context, data) {
+    const status = this.mapBusinessUnitStatus(data.status);
+    const result = {
+      identifier: {
+        key: data.id
+      },
+      companyIdentifier: {
+        taxIdentifier: data.key
+      },
+      name: data.name,
+      pointOfContact: {
+        email: data.contactEmail ?? ""
+      },
+      status
+    };
+    return CompanyRegistrationRequestSchema.parse(result);
+  }
+  mapBusinessUnitStatus(status) {
+    switch (status) {
+      case "Active":
+        return "approved";
+      case "Inactive":
+        return "pending";
+      default:
+        return "pending";
+    }
+  }
+}
+export {
+  CommercetoolsCompanyRegistrationFactory
+};

package/factories/employee/employee.factory.js

@@ -0,0 +1,61 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsEmployeeFactory {
+  employeeSchema;
+  employeePaginatedListSchema;
+  constructor(employeeSchema, employeePaginatedListSchema) {
+    this.employeeSchema = employeeSchema;
+    this.employeePaginatedListSchema = employeePaginatedListSchema;
+  }
+  parseEmployee(_context, input) {
+    const result = {
+      identifier: { userId: input.associate.customer.id },
+      company: input.company,
+      firstName: input.associate.customer.obj?.firstName,
+      lastName: input.associate.customer.obj?.lastName,
+      email: input.associate.customer.obj?.email || "",
+      role: this.parseRole(input.associate.associateRoleAssignments[0]?.associateRole.key)
+    };
+    return this.employeeSchema.parse(result);
+  }
+  parseEmployeePaginatedList(context, data, query) {
+    const totalPages = query.search.paginationOptions.pageSize > 0 ? Math.ceil(data.totalCount / query.search.paginationOptions.pageSize) : 0;
+    const result = {
+      identifier: query.search,
+      pageNumber: query.search.paginationOptions.pageNumber,
+      pageSize: query.search.paginationOptions.pageSize,
+      totalCount: data.totalCount,
+      totalPages,
+      items: data.items.map((associate) => this.parseEmployee(context, {
+        company: query.search.company,
+        associate
+      }))
+    };
+    return this.employeePaginatedListSchema.parse(result);
+  }
+  mapRole(role) {
+    switch (role) {
+      case "admin":
+        return "buyer-admin";
+      case "manager":
+        return "buyer-approver";
+      case "employee":
+        return "buyer";
+    }
+    return "buyer";
+  }
+  parseRole(role) {
+    switch (role) {
+      case "buyer-admin":
+        return "admin";
+      case "buyer-approver":
+        return "manager";
+      case "buyer":
+        return "employee";
+    }
+    return "employee";
+  }
+}
+export {
+  CommercetoolsEmployeeFactory
+};