@reactionary/medusa 0.10.22 → 0.10.24

package/capabilities/employee.capability.js

@@ -0,0 +1,265 @@
+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 { FetchError } from "@medusajs/js-sdk";
+import {
+  EmployeeCapability,
+  EmployeeMutationAssignRoleSchema,
+  EmployeeMutationRemoveEmployeeSchema,
+  EmployeeMutationUnassignRoleSchema,
+  EmployeePaginatedListSchema,
+  EmployeeQueryByEmailSchema,
+  EmployeeQueryListSchema,
+  EmployeeSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import { handleProviderError } from "../utils/medusa-helpers.js";
+const debug = createDebug("reactionary:medusa:employee");
+const EMPLOYEE_FIELDS = ["*", "customer.*"].join(",");
+class MedusaEmployeeCapability extends EmployeeCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  medusaApi;
+  config;
+  factory;
+  // company.taxIdentifier is the real, caller-chosen business tax id - not the Medusa-internal company
+  // id the REST API is keyed by - so it has to be resolved to that id before it can be used in a path.
+  async resolveCompanyId(taxIdentifier) {
+    const client = await this.medusaApi.getClient();
+    try {
+      const response = await client.client.fetch(
+        `/store/companies/by-tax-identifier/${encodeURIComponent(taxIdentifier)}`,
+        { method: "GET" }
+      );
+      return response.company.id;
+    } catch (err) {
+      if (err instanceof FetchError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  /**
+   * ponytail: there's no `customer_id` or `role` filter on the backend's employee list route, so
+   * resolving an employee by customer id, or listing by role, means scanning the company's employee
+   * list client-side via iterateCompanyEmployeePages. Upgrade path: ask the backend to add `customer_id`
+   * and `role` filters to `StoreGetEmployeeParams`.
+   */
+  async fetchCompanyEmployees(companyId, opts = {}) {
+    const client = await this.medusaApi.getClient();
+    const response = await client.client.fetch(`/store/companies/${companyId}/employees`, {
+      method: "GET",
+      query: {
+        fields: EMPLOYEE_FIELDS,
+        email: opts.email,
+        q: opts.q,
+        limit: opts.limit ?? 1e3,
+        offset: opts.offset ?? 0
+      }
+    });
+    return { employees: response.employees, count: response.count };
+  }
+  async *iterateCompanyEmployeePages(companyId, opts = {}) {
+    const pageSize = 1e3;
+    let offset = 0;
+    let count = Infinity;
+    while (offset < count) {
+      const page = await this.fetchCompanyEmployees(companyId, { ...opts, limit: pageSize, offset });
+      yield page.employees;
+      count = page.count;
+      offset += pageSize;
+    }
+  }
+  async findEmployeeByCustomerId(companyId, customerId) {
+    for await (const employees of this.iterateCompanyEmployeePages(companyId)) {
+      const match = employees.find((employee) => employee.customer?.id === customerId);
+      if (match) {
+        return match;
+      }
+    }
+    return void 0;
+  }
+  async listEmployees(payload) {
+    debug("listEmployees", payload);
+    try {
+      const companyId = await this.resolveCompanyId(payload.search.company.taxIdentifier);
+      if (!companyId) {
+        return error({ type: "NotFound", identifier: payload.search.company });
+      }
+      const { pageNumber, pageSize } = payload.search.paginationOptions;
+      const q = [payload.search.firstName, payload.search.lastName].filter(Boolean).join(" ") || void 0;
+      let employees;
+      let count;
+      if (payload.search.role) {
+        const role = this.factory.mapRole(payload.search.role);
+        const matches = [];
+        for await (const page2 of this.iterateCompanyEmployeePages(companyId, { email: payload.search.email, q })) {
+          matches.push(...page2.filter((employee) => employee.role === role));
+        }
+        const start = (pageNumber - 1) * pageSize;
+        employees = matches.slice(start, start + pageSize);
+        count = matches.length;
+      } else {
+        ({ employees, count } = await this.fetchCompanyEmployees(companyId, {
+          email: payload.search.email,
+          q,
+          limit: pageSize,
+          offset: (pageNumber - 1) * pageSize
+        }));
+      }
+      const page = employees.map((employee) => ({
+        company: payload.search.company,
+        employee
+      }));
+      return success(
+        this.factory.parseEmployeePaginatedList(
+          this.context,
+          { items: page, totalCount: count },
+          payload
+        )
+      );
+    } catch (err) {
+      handleProviderError("list employees", err);
+    }
+  }
+  async getByEmail(payload) {
+    debug("getByEmail", payload);
+    try {
+      const companyId = await this.resolveCompanyId(payload.company.taxIdentifier);
+      if (!companyId) {
+        return error({ type: "NotFound", identifier: payload.company });
+      }
+      const { employees } = await this.fetchCompanyEmployees(companyId, { email: payload.email });
+      const employee = employees[0];
+      if (!employee) {
+        return error({ type: "NotFound", identifier: payload });
+      }
+      return success(
+        this.factory.parseEmployee(this.context, { company: payload.company, employee })
+      );
+    } catch (err) {
+      handleProviderError("get employee by email", err);
+    }
+  }
+  async updateEmployeeRole(company, employeeIdentifier, role) {
+    const companyId = await this.resolveCompanyId(company.taxIdentifier);
+    if (!companyId) {
+      return error({ type: "NotFound", identifier: company });
+    }
+    const existing = await this.findEmployeeByCustomerId(companyId, employeeIdentifier.userId);
+    if (!existing) {
+      return error({ type: "NotFound", identifier: employeeIdentifier });
+    }
+    const client = await this.medusaApi.getClient();
+    const response = await client.client.fetch(
+      `/store/companies/${companyId}/employees/${existing.id}`,
+      {
+        method: "POST",
+        body: { role },
+        query: { fields: EMPLOYEE_FIELDS }
+      }
+    );
+    return success(
+      this.factory.parseEmployee(this.context, {
+        company,
+        employee: response.employee
+      })
+    );
+  }
+  async assignRole(payload) {
+    debug("assignRole", payload);
+    try {
+      return await this.updateEmployeeRole(
+        payload.company,
+        payload.employeeIdentifier,
+        this.factory.mapRole(payload.role)
+      );
+    } catch (err) {
+      handleProviderError("assign employee role", err);
+    }
+  }
+  async unassignRole(payload) {
+    debug("unassignRole", payload);
+    try {
+      return await this.updateEmployeeRole(
+        payload.company,
+        payload.employeeIdentifier,
+        "employee"
+      );
+    } catch (err) {
+      handleProviderError("unassign employee role", err);
+    }
+  }
+  async removeEmployee(payload) {
+    debug("removeEmployee", payload);
+    try {
+      const companyId = await this.resolveCompanyId(payload.company.taxIdentifier);
+      if (!companyId) {
+        return error({ type: "NotFound", identifier: payload.company });
+      }
+      const existing = await this.findEmployeeByCustomerId(
+        companyId,
+        payload.employeeIdentifier.userId
+      );
+      if (!existing) {
+        return error({
+          type: "NotFound",
+          identifier: payload.employeeIdentifier
+        });
+      }
+      const client = await this.medusaApi.getClient();
+      await client.client.fetch(`/store/companies/${companyId}/employees/${existing.id}`, {
+        method: "DELETE"
+      });
+      return success(void 0);
+    } catch (err) {
+      handleProviderError("remove employee", err);
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeQueryListSchema,
+    outputSchema: EmployeePaginatedListSchema
+  })
+], MedusaEmployeeCapability.prototype, "listEmployees", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeQueryByEmailSchema,
+    outputSchema: EmployeeSchema
+  })
+], MedusaEmployeeCapability.prototype, "getByEmail", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeMutationAssignRoleSchema,
+    outputSchema: EmployeeSchema
+  })
+], MedusaEmployeeCapability.prototype, "assignRole", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeMutationUnassignRoleSchema,
+    outputSchema: EmployeeSchema
+  })
+], MedusaEmployeeCapability.prototype, "unassignRole", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeMutationRemoveEmployeeSchema
+  })
+], MedusaEmployeeCapability.prototype, "removeEmployee", 1);
+export {
+  MedusaEmployeeCapability
+};

package/core/initialize.js

@@ -5,6 +5,14 @@ import {
   CategoryPaginatedResultSchema,
   CategorySchema,
   CheckoutSchema,
+  CompanySchema,
+  CompanyPaginatedListSchema,
+  CompanyRegistrationRequestSchema,
+  EmployeeSchema,
+  EmployeePaginatedListSchema,
+  EmployeeInvitationSchema,
+  EmployeeIssuedInvitationSchema,
+  EmployeeInvitationPaginatedListSchema,
   InventorySchema,
   OrderSchema,
   OrderSearchResultSchema,
@@ -20,6 +28,10 @@ import {
 import { MedusaCartCapability } from "../capabilities/cart.capability.js";
 import { MedusaCategoryCapability } from "../capabilities/category.capability.js";
 import { MedusaCheckoutCapability } from "../capabilities/checkout.capability.js";
+import { MedusaCompanyCapability } from "../capabilities/company.capability.js";
+import { MedusaCompanyRegistrationCapability } from "../capabilities/company-registration.capability.js";
+import { MedusaEmployeeCapability } from "../capabilities/employee.capability.js";
+import { MedusaEmployeeInvitationCapability } from "../capabilities/employee-invitation.capability.js";
 import { MedusaIdentityCapability } from "../capabilities/identity.capability.js";
 import { MedusaInventoryCapability } from "../capabilities/inventory.capability.js";
 import { MedusaOrderSearchCapability } from "../capabilities/order-search.capability.js";
@@ -42,6 +54,10 @@ import {
   MedusaCartFactory,
   MedusaCategoryFactory,
   MedusaCheckoutFactory,
+  MedusaCompanyFactory,
+  MedusaCompanyRegistrationFactory,
+  MedusaEmployeeFactory,
+  MedusaEmployeeInvitationFactory,
   MedusaInventoryFactory,
   MedusaOrderFactory,
   MedusaOrderSearchFactory,
@@ -140,6 +156,74 @@ function withMedusaCapabilities(configuration, capabilities) {
         buildCapabilityArgs
       );
     }
+    if (caps.employee?.enabled) {
+      client.employee = resolveCapabilityWithFactory(
+        capabilities.employee,
+        {
+          factory: new MedusaEmployeeFactory(EmployeeSchema, EmployeePaginatedListSchema),
+          capability: (args) => new MedusaEmployeeCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.employeeInvitation?.enabled) {
+      client.employeeInvitation = resolveCapabilityWithFactory(
+        capabilities.employeeInvitation,
+        {
+          factory: new MedusaEmployeeInvitationFactory(
+            EmployeeInvitationSchema,
+            EmployeeIssuedInvitationSchema,
+            EmployeeInvitationPaginatedListSchema
+          ),
+          capability: (args) => new MedusaEmployeeInvitationCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.company?.enabled) {
+      client.company = resolveCapabilityWithFactory(
+        capabilities.company,
+        {
+          factory: new MedusaCompanyFactory(CompanySchema, CompanyPaginatedListSchema),
+          capability: (args) => new MedusaCompanyCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.companyRegistration?.enabled) {
+      client.companyRegistration = resolveCapabilityWithFactory(
+        capabilities.companyRegistration,
+        {
+          factory: new MedusaCompanyRegistrationFactory(CompanyRegistrationRequestSchema),
+          capability: (args) => new MedusaCompanyRegistrationCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     if (caps.productRecommendations?.enabled) {
       client.productRecommendations = resolveDirectCapability(
         capabilities.productRecommendations,

package/factories/company/company.factory.js

@@ -0,0 +1,83 @@
+import {
+} from "@reactionary/core";
+const EMPTY_ADDRESS = {
+  identifier: { nickName: "" },
+  firstName: "",
+  lastName: "",
+  streetAddress: "",
+  streetNumber: "",
+  city: "",
+  region: "",
+  postalCode: "",
+  countryCode: ""
+};
+class MedusaCompanyFactory {
+  companySchema;
+  companyPaginatedListSchema;
+  constructor(companySchema, companyPaginatedListSchema) {
+    this.companySchema = companySchema;
+    this.companyPaginatedListSchema = companyPaginatedListSchema;
+  }
+  parseAddress(raw) {
+    return {
+      identifier: { nickName: raw.address_name ?? "" },
+      firstName: raw.first_name,
+      lastName: raw.last_name,
+      streetAddress: raw.street_address,
+      streetNumber: raw.street_number ?? "",
+      city: raw.city,
+      region: raw.region ?? "",
+      postalCode: raw.postal_code,
+      countryCode: raw.country_code
+    };
+  }
+  parseCompany(_context, data) {
+    const addresses = data.addresses ?? [];
+    const billing = addresses.find((a) => a.type === "billing" && a.is_default) ?? addresses.find((a) => a.type === "billing");
+    const shippingAddresses = addresses.filter((a) => a.type === "shipping");
+    const shipping = shippingAddresses.find((a) => a.is_default);
+    const alternateShippingAddresses = shippingAddresses.filter((a) => !a.is_default).map((a) => this.parseAddress(a));
+    const result = {
+      identifier: { taxIdentifier: data.tax_identifier },
+      dunsIdentifier: data.duns_identifier ?? void 0,
+      tinIdentifier: data.tin_identifier ?? void 0,
+      name: data.name,
+      logo: data.logo_url ? {
+        sourceUrl: data.logo_url,
+        altText: data.logo_alt_text ?? "",
+        width: data.logo_width ?? void 0,
+        height: data.logo_height ?? void 0
+      } : void 0,
+      // ponytail: core's CompanyStatus only has 2 values (active/blocked), but the backend has 3
+      // (active/pending_approval/blocked) - pending_approval collapses into blocked here. Use
+      // CompanyRegistrationRequest's status instead (see MedusaCompanyRegistrationFactory) when the
+      // pending/denied distinction matters, e.g. right after requestRegistration.
+      status: data.status === "active" ? "active" : "blocked",
+      pointOfContact: { email: data.email, phone: data.phone ?? void 0 },
+      // "Default shipping address if different from default billing address" (per CompanySchema) - so
+      // absent an explicit shipping default, ship-to-billing is the implied default.
+      shippingAddress: shipping ? this.parseAddress(shipping) : billing ? this.parseAddress(billing) : void 0,
+      billingAddress: billing ? this.parseAddress(billing) : EMPTY_ADDRESS,
+      alternateShippingAddresses,
+      isCustomAddressesAllowed: data.is_custom_addresses_allowed,
+      isSelfManagementOfShippingAddressesAllowed: data.is_self_management_of_shipping_addresses_allowed
+    };
+    return this.companySchema.parse(result);
+  }
+  parseCompanyPaginatedList(context, data, query) {
+    const items = data.items.map((item) => this.parseCompany(context, item));
+    const { pageNumber, pageSize } = query.search.paginationOptions;
+    const result = {
+      identifier: query.search,
+      pageNumber,
+      pageSize,
+      totalCount: data.totalCount,
+      totalPages: Math.ceil(data.totalCount / pageSize),
+      items
+    };
+    return this.companyPaginatedListSchema.parse(result);
+  }
+}
+export {
+  MedusaCompanyFactory
+};

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

@@ -0,0 +1,31 @@
+import {
+} from "@reactionary/core";
+class MedusaCompanyRegistrationFactory {
+  companyRegistrationRequestSchema;
+  constructor(companyRegistrationRequestSchema) {
+    this.companyRegistrationRequestSchema = companyRegistrationRequestSchema;
+  }
+  parseCompanyRegistrationRequest(_context, data) {
+    const result = {
+      identifier: { key: data.id },
+      companyIdentifier: { taxIdentifier: data.tax_identifier },
+      name: data.name,
+      pointOfContact: { email: data.email, phone: data.phone ?? void 0 },
+      status: this.parseStatus(data.status)
+    };
+    return this.companyRegistrationRequestSchema.parse(result);
+  }
+  parseStatus(status) {
+    switch (status) {
+      case "active":
+        return "approved";
+      case "pending_approval":
+        return "pending";
+      default:
+        return "denied";
+    }
+  }
+}
+export {
+  MedusaCompanyRegistrationFactory
+};

package/factories/employee/employee.factory.js

@@ -0,0 +1,48 @@
+import {
+} from "@reactionary/core";
+class MedusaEmployeeFactory {
+  employeeSchema;
+  employeePaginatedListSchema;
+  constructor(employeeSchema, employeePaginatedListSchema) {
+    this.employeeSchema = employeeSchema;
+    this.employeePaginatedListSchema = employeePaginatedListSchema;
+  }
+  parseEmployee(context, data) {
+    const customer = data.employee.customer;
+    const result = {
+      identifier: { userId: customer?.id ?? "" },
+      company: data.company,
+      firstName: customer?.first_name ?? void 0,
+      lastName: customer?.last_name ?? void 0,
+      email: customer?.email ?? "",
+      spendingLimit: data.employee.spending_limit === void 0 ? void 0 : {
+        value: data.employee.spending_limit,
+        currency: context.languageContext.currencyCode
+      },
+      role: this.parseRole(data.employee.role)
+    };
+    return this.employeeSchema.parse(result);
+  }
+  parseEmployeePaginatedList(context, data, query) {
+    const items = data.items.map((item) => this.parseEmployee(context, item));
+    const { pageNumber, pageSize } = query.search.paginationOptions;
+    const result = {
+      identifier: query.search,
+      pageNumber,
+      pageSize,
+      totalCount: data.totalCount,
+      totalPages: Math.ceil(data.totalCount / pageSize),
+      items
+    };
+    return this.employeePaginatedListSchema.parse(result);
+  }
+  mapRole(role) {
+    return role;
+  }
+  parseRole(role) {
+    return role;
+  }
+}
+export {
+  MedusaEmployeeFactory
+};

package/factories/employee-invitation/employee-invitation.factory.js

@@ -0,0 +1,79 @@
+import {
+} from "@reactionary/core";
+function makeInvitationKey(companyId, invitationId) {
+  return `${companyId}:${invitationId}`;
+}
+function parseInvitationKey(key) {
+  const separatorIndex = key.indexOf(":");
+  return {
+    companyId: key.slice(0, separatorIndex),
+    invitationId: key.slice(separatorIndex + 1)
+  };
+}
+const NEVER_EXPIRES = (/* @__PURE__ */ new Date(864e13)).toISOString();
+class MedusaEmployeeInvitationFactory {
+  employeeInvitationSchema;
+  employeeIssuedInvitationSchema;
+  employeeInvitationPaginatedListSchema;
+  constructor(employeeInvitationSchema, employeeIssuedInvitationSchema, employeeInvitationPaginatedListSchema) {
+    this.employeeInvitationSchema = employeeInvitationSchema;
+    this.employeeIssuedInvitationSchema = employeeIssuedInvitationSchema;
+    this.employeeInvitationPaginatedListSchema = employeeInvitationPaginatedListSchema;
+  }
+  parseEmployeeInvitation(_context, data, _payload) {
+    const result = {
+      identifier: { key: makeInvitationKey(data.company_id, data.id) },
+      company: { taxIdentifier: data.company?.tax_identifier ?? "" },
+      status: this.parseStatus(data.status),
+      email: data.email,
+      role: this.parseRole(data.role),
+      validUntil: data.validUntil ? new Date(data.validUntil).toISOString() : NEVER_EXPIRES
+    };
+    return this.employeeInvitationSchema.parse(result);
+  }
+  parseEmployeeIssuedInvitation(context, data, payload) {
+    const invitation = this.parseEmployeeInvitation(context, data, payload);
+    const result = {
+      ...invitation,
+      // ponytail: only the invite-creation response carries this (see MedusaRawEmployeeInvitation);
+      // empty string here would mean this was called from a path that doesn't have one, which shouldn't
+      // happen - the capability only calls parseEmployeeIssuedInvitation right after a create response.
+      securityToken: data.securityToken ?? ""
+    };
+    return this.employeeIssuedInvitationSchema.parse(result);
+  }
+  parseEmployeeInvitationPaginatedList(context, data, query) {
+    const items = data.items.map((item) => this.parseEmployeeInvitation(context, item));
+    const { pageNumber, pageSize } = query.search.paginationOptions;
+    const result = {
+      identifier: query.search,
+      pageNumber,
+      pageSize,
+      totalCount: data.totalCount,
+      totalPages: Math.ceil(data.totalCount / pageSize),
+      items
+    };
+    return this.employeeInvitationPaginatedListSchema.parse(result);
+  }
+  mapRole(role) {
+    return role;
+  }
+  parseRole(role) {
+    return role;
+  }
+  parseStatus(status) {
+    switch (status) {
+      case "accepted":
+        return "accepted";
+      case "revoked":
+        return "revoked";
+      default:
+        return "invited";
+    }
+  }
+}
+export {
+  MedusaEmployeeInvitationFactory,
+  makeInvitationKey,
+  parseInvitationKey
+};

package/factories/index.js

@@ -1,6 +1,10 @@
 export * from "./cart/cart.factory.js";
 export * from "./category/category.factory.js";
 export * from "./checkout/checkout.factory.js";
+export * from "./company/company.factory.js";
+export * from "./company-registration/company-registration.factory.js";
+export * from "./employee/employee.factory.js";
+export * from "./employee-invitation/employee-invitation.factory.js";
 export * from "./identity/identity.factory.js";
 export * from "./inventory/inventory.factory.js";
 export * from "./order/order.factory.js";

package/index.js

@@ -6,6 +6,10 @@ export * from "./core/initialize.types.js";
 export * from "./core/client.js";
 export * from "./factories/index.js";
 export * from "./capabilities/cart.capability.js";
+export * from "./capabilities/company.capability.js";
+export * from "./capabilities/company-registration.capability.js";
+export * from "./capabilities/employee.capability.js";
+export * from "./capabilities/employee-invitation.capability.js";
 export * from "./capabilities/identity.capability.js";
 export * from "./capabilities/inventory.capability.js";
 export * from "./capabilities/order.capability.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/medusa",
-  "version": "0.10.22",
+  "version": "0.10.24",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@medusajs/js-sdk": "^2.13.3",
-    "@reactionary/core": "0.10.22",
+    "@reactionary/core": "0.10.24",
     "debug": "^4.4.3",
     "@medusajs/types": "^2.13.3",
     "zod": "4.1.9"

package/schema/capabilities.schema.js

@@ -23,7 +23,8 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   identity: true,
   profile: true,
   productAssociations: true,
-  personalizationProfile: true
+  personalizationProfile: true,
+  company: true
 }).extend({
   product: OverridableCapabilitySchema.optional(),
   productSearch: OverridableCapabilitySchema.optional(),
@@ -35,6 +36,10 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   orderSearch: OverridableCapabilitySchema.optional(),
   inventory: OverridableCapabilitySchema.optional(),
   identity: DirectCapabilitySchema.optional(),
+  employee: OverridableCapabilitySchema.optional(),
+  employeeInvitation: OverridableCapabilitySchema.optional(),
+  company: OverridableCapabilitySchema.optional(),
+  companyRegistration: OverridableCapabilitySchema.optional(),
   profile: OverridableCapabilitySchema.optional(),
   productAssociations: OverridableCapabilitySchema.optional(),
   productRecommendations: DirectCapabilitySchema.optional(),