@reactionary/medusa 0.10.23 → 0.10.24

package/capabilities/company-registration.capability.js

@@ -0,0 +1,116 @@
+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 {
+  CompanyRegistrationCapability,
+  CompanyRegistrationMutationRegisterSchema,
+  CompanyRegistrationQueryCheckRegistrationStatusSchema,
+  CompanyRegistrationRequestSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import { handleProviderError } from "../utils/medusa-helpers.js";
+const debug = createDebug("reactionary:medusa:company-registration");
+class MedusaCompanyRegistrationCapability extends CompanyRegistrationCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  medusaApi;
+  config;
+  factory;
+  async fetchCompany(companyId) {
+    const client = await this.medusaApi.getClient();
+    try {
+      const response = await client.client.fetch(
+        `/store/companies/${companyId}`,
+        { method: "GET" }
+      );
+      return response.company;
+    } catch (err) {
+      if (err instanceof FetchError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  addressPayload(address) {
+    return {
+      address_name: address.identifier.nickName,
+      first_name: address.firstName,
+      last_name: address.lastName,
+      street_address: address.streetAddress,
+      street_number: address.streetNumber,
+      city: address.city,
+      region: address.region,
+      postal_code: address.postalCode,
+      country_code: address.countryCode
+    };
+  }
+  async requestRegistration(payload) {
+    debug("requestRegistration", payload);
+    try {
+      const client = await this.medusaApi.getClient();
+      const createResponse = await client.client.fetch(
+        "/store/company-registrations",
+        {
+          method: "POST",
+          body: {
+            name: payload.name,
+            email: payload.pointOfContact.email,
+            phone: payload.pointOfContact.phone,
+            tax_identifier: payload.taxIdentifier,
+            duns_identifier: payload.dunsIdentifier,
+            tin_identifier: payload.tinIdentifier,
+            currency_code: this.context.languageContext.currencyCode.toLowerCase(),
+            billing_address: this.addressPayload(payload.billingAddress)
+          }
+        }
+      );
+      return success(
+        this.factory.parseCompanyRegistrationRequest(this.context, createResponse.company)
+      );
+    } catch (err) {
+      handleProviderError("request company registration", err);
+    }
+  }
+  async checkRequestStatus(payload) {
+    debug("checkRequestStatus", payload);
+    try {
+      const company = await this.fetchCompany(payload.requestIdentifier.key);
+      if (!company) {
+        return error({ type: "NotFound", identifier: payload.requestIdentifier });
+      }
+      return success(this.factory.parseCompanyRegistrationRequest(this.context, company));
+    } catch (err) {
+      handleProviderError("check company registration status", err);
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyRegistrationMutationRegisterSchema,
+    outputSchema: CompanyRegistrationRequestSchema
+  })
+], MedusaCompanyRegistrationCapability.prototype, "requestRegistration", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyRegistrationQueryCheckRegistrationStatusSchema,
+    outputSchema: CompanyRegistrationRequestSchema
+  })
+], MedusaCompanyRegistrationCapability.prototype, "checkRequestStatus", 1);
+export {
+  MedusaCompanyRegistrationCapability
+};

package/capabilities/company.capability.js

@@ -0,0 +1,257 @@
+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 {
+  CompanyCapability,
+  CompanyMutationAddShippingAddressSchema,
+  CompanyMutationMakeShippingAddressDefaultSchema,
+  CompanyMutationRemoveShippingAddressSchema,
+  CompanyMutationUpdateShippingAddressSchema,
+  CompanyPaginatedListSchema,
+  CompanyQueryByIdSchema,
+  CompanyQueryListSchema,
+  CompanySchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import { handleProviderError } from "../utils/medusa-helpers.js";
+const debug = createDebug("reactionary:medusa:company");
+class MedusaCompanyCapability extends CompanyCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  medusaApi;
+  config;
+  factory;
+  async fetchCompany(companyId) {
+    const client = await this.medusaApi.getClient();
+    try {
+      const response = await client.client.fetch(
+        `/store/companies/${companyId}`,
+        { method: "GET" }
+      );
+      return response.company;
+    } catch (err) {
+      if (err instanceof FetchError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async fetchCompanyOrThrow(companyId) {
+    const company = await this.fetchCompany(companyId);
+    if (!company) {
+      throw new Error(`Company ${companyId} disappeared after mutation`);
+    }
+    return company;
+  }
+  async fetchCompanyByTaxIdentifier(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;
+    } catch (err) {
+      if (err instanceof FetchError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  findAddress(company, nickName, type) {
+    return company.addresses?.find(
+      (a) => a.type === type && (a.address_name ?? "") === nickName
+    );
+  }
+  addressPayload(address) {
+    return {
+      address_name: address.identifier.nickName,
+      first_name: address.firstName,
+      last_name: address.lastName,
+      street_address: address.streetAddress,
+      street_number: address.streetNumber,
+      city: address.city,
+      region: address.region,
+      postal_code: address.postalCode,
+      country_code: address.countryCode
+    };
+  }
+  async getById(payload) {
+    try {
+      const company = await this.fetchCompanyByTaxIdentifier(payload.identifier.taxIdentifier);
+      if (!company) {
+        return error({ type: "NotFound", identifier: payload.identifier });
+      }
+      return success(this.factory.parseCompany(this.context, company));
+    } catch (err) {
+      handleProviderError("get company", err);
+    }
+  }
+  async listCompanies(payload) {
+    debug("listCompanies", payload);
+    try {
+      const client = await this.medusaApi.getClient();
+      const response = await client.client.fetch("/store/customers/me/employees", { method: "GET" });
+      const companyIds = Array.from(new Set(response.employees.map((e) => e.company.id)));
+      const { pageNumber, pageSize } = payload.search.paginationOptions;
+      const start = (pageNumber - 1) * pageSize;
+      const pageIds = companyIds.slice(start, start + pageSize);
+      const companies = (await Promise.all(pageIds.map((id) => this.fetchCompany(id)))).filter(
+        (company) => company !== null
+      );
+      return success(
+        this.factory.parseCompanyPaginatedList(
+          this.context,
+          { items: companies, totalCount: companyIds.length },
+          payload
+        )
+      );
+    } catch (err) {
+      handleProviderError("list companies", err);
+    }
+  }
+  async addShippingAddress(payload) {
+    debug("addShippingAddress", payload);
+    try {
+      const company = await this.fetchCompanyByTaxIdentifier(payload.company.taxIdentifier);
+      if (!company) {
+        return error({ type: "NotFound", identifier: payload.company });
+      }
+      const companyId = company.id;
+      const existing = this.findAddress(company, payload.address.identifier.nickName, "shipping");
+      if (existing) {
+        return error({
+          type: "InvalidInput",
+          error: "A shipping address with the same nickname already exists"
+        });
+      }
+      const client = await this.medusaApi.getClient();
+      await client.client.fetch(`/store/companies/${companyId}/addresses`, {
+        method: "POST",
+        body: { ...this.addressPayload(payload.address), type: "shipping", is_default: false }
+      });
+      return success(this.factory.parseCompany(this.context, await this.fetchCompanyOrThrow(companyId)));
+    } catch (err) {
+      handleProviderError("add shipping address", err);
+    }
+  }
+  async updateShippingAddress(payload) {
+    debug("updateShippingAddress", payload);
+    try {
+      const company = await this.fetchCompanyByTaxIdentifier(payload.company.taxIdentifier);
+      if (!company) {
+        return error({ type: "NotFound", identifier: payload.company });
+      }
+      const companyId = company.id;
+      const existing = this.findAddress(company, payload.address.identifier.nickName, "shipping");
+      if (!existing) {
+        return error({ type: "NotFound", identifier: payload.address.identifier });
+      }
+      const client = await this.medusaApi.getClient();
+      await client.client.fetch(`/store/companies/${companyId}/addresses/${existing.id}`, {
+        method: "POST",
+        body: this.addressPayload(payload.address)
+      });
+      return success(this.factory.parseCompany(this.context, await this.fetchCompanyOrThrow(companyId)));
+    } catch (err) {
+      handleProviderError("update shipping address", err);
+    }
+  }
+  async removeShippingAddress(payload) {
+    debug("removeShippingAddress", payload);
+    try {
+      const company = await this.fetchCompanyByTaxIdentifier(payload.company.taxIdentifier);
+      if (!company) {
+        return error({ type: "NotFound", identifier: payload.company });
+      }
+      const companyId = company.id;
+      const existing = this.findAddress(company, payload.addressIdentifier.nickName, "shipping");
+      if (!existing) {
+        return error({ type: "NotFound", identifier: payload.addressIdentifier });
+      }
+      const client = await this.medusaApi.getClient();
+      await client.client.fetch(`/store/companies/${companyId}/addresses/${existing.id}`, {
+        method: "DELETE"
+      });
+      return success(this.factory.parseCompany(this.context, await this.fetchCompanyOrThrow(companyId)));
+    } catch (err) {
+      handleProviderError("remove shipping address", err);
+    }
+  }
+  async makeShippingAddressDefault(payload) {
+    debug("makeShippingAddressDefault", payload);
+    try {
+      const company = await this.fetchCompanyByTaxIdentifier(payload.company.taxIdentifier);
+      if (!company) {
+        return error({ type: "NotFound", identifier: payload.company });
+      }
+      const companyId = company.id;
+      const existing = this.findAddress(company, payload.addressIdentifier.nickName, "shipping");
+      if (!existing) {
+        return error({ type: "NotFound", identifier: payload.addressIdentifier });
+      }
+      const client = await this.medusaApi.getClient();
+      await client.client.fetch(`/store/companies/${companyId}/addresses/${existing.id}`, {
+        method: "POST",
+        body: { is_default: true }
+      });
+      return success(this.factory.parseCompany(this.context, await this.fetchCompanyOrThrow(companyId)));
+    } catch (err) {
+      handleProviderError("make shipping address default", err);
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyQueryByIdSchema,
+    outputSchema: CompanySchema
+  })
+], MedusaCompanyCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyQueryListSchema,
+    outputSchema: CompanyPaginatedListSchema
+  })
+], MedusaCompanyCapability.prototype, "listCompanies", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyMutationAddShippingAddressSchema,
+    outputSchema: CompanySchema
+  })
+], MedusaCompanyCapability.prototype, "addShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyMutationUpdateShippingAddressSchema,
+    outputSchema: CompanySchema
+  })
+], MedusaCompanyCapability.prototype, "updateShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyMutationRemoveShippingAddressSchema,
+    outputSchema: CompanySchema
+  })
+], MedusaCompanyCapability.prototype, "removeShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CompanyMutationMakeShippingAddressDefaultSchema,
+    outputSchema: CompanySchema
+  })
+], MedusaCompanyCapability.prototype, "makeShippingAddressDefault", 1);
+export {
+  MedusaCompanyCapability
+};

package/capabilities/employee-invitation.capability.js

@@ -0,0 +1,221 @@
+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 {
+  EmployeeInvitationCapability,
+  EmployeeInvitationMutationAcceptInvitationSchema,
+  EmployeeInvitationMutationInviteEmployeeSchema,
+  EmployeeInvitationMutationRevokeInvitationSchema,
+  EmployeeInvitationSchema,
+  EmployeeInvitationPaginatedListSchema,
+  EmployeeInvitationQueryListSchema,
+  EmployeeIssuedInvitationSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import {
+  parseInvitationKey
+} from "../factories/employee-invitation/employee-invitation.factory.js";
+import { handleProviderError } from "../utils/medusa-helpers.js";
+const debug = createDebug("reactionary:medusa:employee-invitation");
+const EMPLOYEE_INVITATION_FIELDS = [
+  "id",
+  "email",
+  "role",
+  "status",
+  "company_id",
+  "company.tax_identifier",
+  "accepted_at",
+  "validUntil"
+].join(",");
+class MedusaEmployeeInvitationCapability extends EmployeeInvitationCapability {
+  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;
+    }
+  }
+  // The accept-invitation route returns the raw workflow result rather than a query.graph response, so
+  // it never includes the nested `company` relation (only the `company_id` scalar column) - this is
+  // used to look the company back up by that id, purely to read its real tax_identifier.
+  async fetchCompany(companyId) {
+    const client = await this.medusaApi.getClient();
+    try {
+      const response = await client.client.fetch(
+        `/store/companies/${companyId}`,
+        { method: "GET", query: { fields: "tax_identifier" } }
+      );
+      return response.company;
+    } catch (err) {
+      if (err instanceof FetchError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async inviteEmployee(payload) {
+    debug("inviteEmployee", payload);
+    try {
+      const companyId = await this.resolveCompanyId(payload.company.taxIdentifier);
+      if (!companyId) {
+        return error({ type: "NotFound", identifier: payload.company });
+      }
+      const client = await this.medusaApi.getClient();
+      const response = await client.client.fetch(`/store/companies/${companyId}/employee-invitations`, {
+        method: "POST",
+        body: {
+          email: payload.email,
+          role: this.factory.mapRole(payload.role)
+        },
+        query: { fields: EMPLOYEE_INVITATION_FIELDS }
+      });
+      return success(
+        this.factory.parseEmployeeIssuedInvitation(
+          this.context,
+          response.employee_invitation,
+          payload
+        )
+      );
+    } catch (err) {
+      handleProviderError("invite employee", err);
+    }
+  }
+  async acceptInvitation(payload) {
+    debug("acceptInvitation", { invitationIdentifier: payload.invitationIdentifier });
+    try {
+      const { invitationId } = parseInvitationKey(payload.invitationIdentifier.key);
+      const client = await this.medusaApi.getClient();
+      const response = await client.client.fetch(`/store/employee-invitations/${invitationId}/accept`, {
+        method: "POST",
+        body: { securityToken: payload.securityToken }
+      });
+      const company = await this.fetchCompany(response.employee_invitation.company_id);
+      return success(
+        this.factory.parseEmployeeInvitation(this.context, {
+          ...response.employee_invitation,
+          company: company ?? void 0
+        })
+      );
+    } catch (err) {
+      handleProviderError("accept invitation", err);
+    }
+  }
+  async revokeInvitation(payload) {
+    debug("revokeInvitation", payload);
+    try {
+      const { companyId, invitationId } = parseInvitationKey(
+        payload.invitationIdentifier.key
+      );
+      const client = await this.medusaApi.getClient();
+      await client.client.fetch(
+        `/store/companies/${companyId}/employee-invitations/${invitationId}`,
+        { method: "DELETE" }
+      );
+      return success(void 0);
+    } catch (err) {
+      handleProviderError("revoke invitation", err);
+    }
+  }
+  async listInvitations(payload) {
+    debug("listInvitations", payload);
+    try {
+      const client = await this.medusaApi.getClient();
+      const { pageNumber, pageSize } = payload.search.paginationOptions;
+      let response;
+      if (payload.search.company) {
+        const companyId = await this.resolveCompanyId(payload.search.company.taxIdentifier);
+        if (!companyId) {
+          return error({ type: "NotFound", identifier: payload.search.company });
+        }
+        response = await client.client.fetch(
+          `/store/companies/${companyId}/employee-invitations`,
+          {
+            method: "GET",
+            query: {
+              fields: EMPLOYEE_INVITATION_FIELDS,
+              email: payload.search.email,
+              limit: pageSize,
+              offset: (pageNumber - 1) * pageSize
+            }
+          }
+        );
+      } else if (payload.search.email) {
+        response = await client.client.fetch("/store/employee-invitations", {
+          method: "GET",
+          query: {
+            fields: EMPLOYEE_INVITATION_FIELDS,
+            limit: pageSize,
+            offset: (pageNumber - 1) * pageSize
+          }
+        });
+      } else {
+        response = { employee_invitations: [], count: 0 };
+      }
+      return success(
+        this.factory.parseEmployeeInvitationPaginatedList(
+          this.context,
+          { items: response.employee_invitations, totalCount: response.count },
+          payload
+        )
+      );
+    } catch (err) {
+      handleProviderError("list invitations", err);
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeInvitationMutationInviteEmployeeSchema,
+    outputSchema: EmployeeIssuedInvitationSchema
+  })
+], MedusaEmployeeInvitationCapability.prototype, "inviteEmployee", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeInvitationMutationAcceptInvitationSchema,
+    outputSchema: EmployeeInvitationSchema
+  })
+], MedusaEmployeeInvitationCapability.prototype, "acceptInvitation", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeInvitationMutationRevokeInvitationSchema
+  })
+], MedusaEmployeeInvitationCapability.prototype, "revokeInvitation", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: EmployeeInvitationQueryListSchema,
+    outputSchema: EmployeeInvitationPaginatedListSchema
+  })
+], MedusaEmployeeInvitationCapability.prototype, "listInvitations", 1);
+export {
+  MedusaEmployeeInvitationCapability
+};