@reactionary/core 0.6.5 → 0.6.7

package/capabilities/analytics.capability.js

@@ -37,15 +37,15 @@ class AnalyticsCapability extends BaseCapability {
         break;
     }
   }
-  async processProductSummaryView(event) {
+  async processProductSummaryView(_event) {
   }
-  async processProductSummaryClick(event) {
+  async processProductSummaryClick(_event) {
   }
-  async processProductDetailsView(event) {
+  async processProductDetailsView(_event) {
   }
-  async processProductAddToCart(event) {
+  async processProductAddToCart(_event) {
   }
-  async processPurchase(event) {
+  async processPurchase(_event) {
   }
 }
 class MulticastAnalyticsCapability extends AnalyticsCapability {

package/capabilities/company-registration.capability.js

@@ -0,0 +1,9 @@
+import { BaseCapability } from "./base.capability.js";
+class CompanyRegistrationCapability extends BaseCapability {
+  getResourceName() {
+    return "company-registration";
+  }
+}
+export {
+  CompanyRegistrationCapability
+};

package/capabilities/company.capability.js

@@ -0,0 +1,59 @@
+import { BaseCapability } from "./base.capability.js";
+class CompanyCapability extends BaseCapability {
+  getResourceName() {
+    return "company";
+  }
+  /**
+   * Sets the current/active billing address for the company
+   *
+   * Usecase: User sets or updates their billing address in their business profile
+   *
+   * It was a design decision not to support multiple billing addresses. The billing address represents who you are as the commercial
+   * entity being billed, and as such it makes sense to have a single authoritative billing address.
+   * @param payload
+   *
+   * NOTE: We are not exposing this for now, as we expect the billing address to be managed from the ERP side
+  public abstract setBillingAddress(payload: CompanyMutationSetBillingAddress): Promise<Result<Company, NotFoundError>>;
+   */
+  /**
+   * Create an empty company object with the given id. This can be used as a fallback when company is not found, to avoid returning null and causing errors in the storefront.
+   * The storefront can then check if the returned company has an empty name or other fields to determine if it is a valid company or a fallback.
+   * @param id
+   */
+  createEmptyCompany(id) {
+    const company = {
+      identifier: {
+        taxIdentifier: id
+      },
+      name: "",
+      dunsIdentifier: void 0,
+      tinIdentifier: void 0,
+      logo: void 0,
+      status: "blocked",
+      pointOfContact: {
+        email: "",
+        phone: void 0
+      },
+      billingAddress: {
+        firstName: "",
+        lastName: "",
+        streetAddress: "",
+        streetNumber: "",
+        city: "",
+        region: "",
+        postalCode: "",
+        countryCode: "",
+        identifier: {
+          nickName: "default"
+        }
+      },
+      alternateShippingAddresses: [],
+      isCustomAddressesAllowed: false,
+      isSelfManagementOfShippingAddressesAllowed: false
+    };
+    return company;
+  }
+}
+export {
+  CompanyCapability
+};

package/capabilities/employee-invitation.capability.js

@@ -0,0 +1,9 @@
+import { BaseCapability } from "./base.capability.js";
+class EmployeeInvitationCapability extends BaseCapability {
+  getResourceName() {
+    return "employee-invitation";
+  }
+}
+export {
+  EmployeeInvitationCapability
+};

package/capabilities/employee.capability.js

@@ -0,0 +1,9 @@
+import { BaseCapability } from "./base.capability.js";
+class EmployeeCapability extends BaseCapability {
+  getResourceName() {
+    return "employees";
+  }
+}
+export {
+  EmployeeCapability
+};

package/capabilities/index.js

@@ -16,3 +16,7 @@ export * from "./product-list.capability.js";
 export * from "./store.capability.js";
 export * from "./order.capability.js";
 export * from "./order-search.capability.js";
+export * from "./company-registration.capability.js";
+export * from "./employee.capability.js";
+export * from "./employee-invitation.capability.js";
+export * from "./company.capability.js";

package/capabilities/product-recommendations.capability.js

@@ -48,28 +48,28 @@ class ProductRecommendationsCapability extends BaseCapability {
     }
     return success([]);
   }
-  async getCollection(query) {
+  async getCollection(_query) {
     return success([]);
   }
-  async getFrequentlyBoughtTogetherRecommendations(query) {
+  async getFrequentlyBoughtTogetherRecommendations(_query) {
     return [];
   }
-  async getSimilarProductsRecommendations(query) {
+  async getSimilarProductsRecommendations(_query) {
     return [];
   }
-  async getTrendingInCategoryRecommendations(query) {
+  async getTrendingInCategoryRecommendations(_query) {
     return [];
   }
-  async getRelatedProductsRecommendations(query) {
+  async getRelatedProductsRecommendations(_query) {
     return [];
   }
-  async getPopularProductsRecommendations(query) {
+  async getPopularProductsRecommendations(_query) {
     return [];
   }
-  async getTopPicksProductsRecommendations(query) {
+  async getTopPicksProductsRecommendations(_query) {
     return [];
   }
-  async getAlsoViewedProductsRecommendations(query) {
+  async getAlsoViewedProductsRecommendations(_query) {
     return [];
   }
   getResourceName() {

package/factories/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",

package/schemas/models/base.model.js

@@ -19,9 +19,14 @@ const ImageSchema = z.looseObject({
   width: z.number().optional().meta({ description: "Width of the original image, in pixels, if known" }),
   height: z.number().optional().meta({ description: "Height of the original image, in pixels, if known" })
 });
+const PointOfContactSchema = z.looseObject({
+  email: z.email().meta({ description: "The contact email for the point of contact" }),
+  phone: z.string().optional().meta({ description: "The contact phone number for the point of contact." })
+});
 export {
   BaseModelSchema,
   ImageSchema,
   PaginationOptionsSchema,
+  PointOfContactSchema,
   createPaginatedResponseSchema
 };

package/schemas/models/checkout.model.js

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import { BaseModelSchema } from "./base.model.js";
+import { BaseModelSchema, PointOfContactSchema } from "./base.model.js";
 import { CartIdentifierSchema, CheckoutIdentifierSchema, CheckoutItemIdentifierSchema, OrderIdentifierSchema, ProductVariantIdentifierSchema } from "./identifiers.model.js";
 import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model.js";
 import { AddressSchema } from "./profile.model.js";
@@ -25,6 +25,7 @@ const CheckoutSchema = BaseModelSchema.extend({
   price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
   name: z.string().default(""),
   description: z.string().default(""),
+  pointOfContact: PointOfContactSchema,
   billingAddress: AddressSchema.optional().nullable(),
   /**
    * Shipping and billing details can be changed on the checkout, but not items or quantities.

package/schemas/models/company-registration.model.js

@@ -0,0 +1,14 @@
+import * as z from "zod";
+import { PointOfContactSchema } from "./base.model.js";
+import { CompanyIdentifierSchema, CompanyRegistrationRequestApprovalStatusSchema, CompanyRegistrationRequestIdentifierSchema } from "./identifiers.model.js";
+const CompanyRegistrationRequestSchema = z.object({
+  identifier: CompanyRegistrationRequestIdentifierSchema,
+  companyIdentifier: CompanyIdentifierSchema,
+  name: z.string(),
+  pointOfContact: PointOfContactSchema,
+  status: CompanyRegistrationRequestApprovalStatusSchema,
+  comment: z.string().optional().meta({ description: "An optional comment from the admin reviewing the company registration. This can be used to provide feedback to the user about why their registration was denied or what they need to do to get approved." })
+});
+export {
+  CompanyRegistrationRequestSchema
+};

package/schemas/models/company.model.js

@@ -0,0 +1,60 @@
+import * as z from "zod";
+import { CompanyIdentifierSchema, CompanySearchIdentifierSchema, EmployeeSearchIdentifierSchema } from "./identifiers.model.js";
+import { createPaginatedResponseSchema, ImageSchema, PointOfContactSchema } from "./base.model.js";
+import { AddressSchema } from "./profile.model.js";
+import { EmployeeSchema } from "./employee.model.js";
+const CompanyStatusSchema = z.enum(["active", "blocked"]);
+const CompanySchema = z.looseObject({
+  identifier: CompanyIdentifierSchema,
+  /**
+   * DUN and Bradstreet identifier. Useful for doing automated credit checks
+   */
+  dunsIdentifier: z.string().optional().meta({ description: "The DUNS number of the company. This is a unique identifier for businesses that can be used for credit reporting and other purposes." }),
+  /**
+   * EU Tax identifier. Useful for reporting and printing
+   */
+  tinIdentifier: z.string().optional().meta({ description: "The TIN (Tax Identification Number) of the company. This is a unique identifier for tax purposes." }),
+  name: z.string().meta({ description: "The name of the company. This is the human readable name that will be displayed in the UI." }),
+  logo: ImageSchema.optional().meta({ description: "The logo of the company. This is the image that will be displayed in the UI to represent the company." }),
+  /**
+   * future
+  parentCompany: CompanyIdentifierSchema.optional(),
+  childOrganizationalEntities: z.array(CompanyIdentifierSchema).optional()
+   */
+  status: CompanyStatusSchema.default("blocked").meta({ description: "The current status of the company in the system. This can be used to determine if the company is active and allowed to perform certain actions, or if it is pending approval or blocked due to violations of terms of service or other issues." }),
+  /**
+   * The legal contact point for this company. Might not be someone with an actual profile on the site.
+   */
+  pointOfContact: PointOfContactSchema.meta({ description: "Email and optional phone for the CFO / signatory of the company" }),
+  /**
+   * Default shipping address if different from default billing address
+   */
+  shippingAddress: AddressSchema.optional().meta({ description: "The default shipping address for the company. This can be used as the default shipping address for orders placed by this company." }),
+  /**
+   * The billing address for this company.
+   */
+  billingAddress: AddressSchema.meta({ description: "The billing address for this company. Not user editable." }),
+  /**
+   * Other allowed shipping addresses
+   */
+  alternateShippingAddresses: z.array(AddressSchema).default(() => []).meta({ description: "Other approved shipping addresses for this company" }),
+  /**
+   * Various indicators the merchant can use to indicate what the company can self-manage.
+   */
+  /**
+   * Can user type in a different shipping address at checkout?
+   */
+  isCustomAddressesAllowed: z.boolean().default(false).meta({ description: "Whether the company allows using custom shipping addresses that are not in the address book. If false, the user must select from the address book when placing an order." }),
+  /**
+   * Can admin users manage the address book of the company, adding and removing shipping addresses as needed?
+   */
+  isSelfManagementOfShippingAddressesAllowed: z.boolean().default(false).meta({ description: "Whether the company allows users to manage their own shipping addresses in an address book. If false, the user must contact support to add or update shipping addresses." })
+});
+const CompanyPaginatedListSchema = createPaginatedResponseSchema(CompanySchema).extend({
+  identifier: CompanySearchIdentifierSchema
+});
+export {
+  CompanyPaginatedListSchema,
+  CompanySchema,
+  CompanyStatusSchema
+};

package/schemas/models/employee-invitation.model.js

@@ -0,0 +1,22 @@
+import * as z from "zod";
+import { createPaginatedResponseSchema } from "./base.model.js";
+import { EmployeeInvitationIdentifierSchema, EmployeeInvitationSearchIdentifierSchema, EmployeeInvitationStatusSchema, EmployeeRoleSchema, CompanyIdentifierSchema } from "./identifiers.model.js";
+const EmployeeInvitationSchema = z.looseObject({
+  identifier: EmployeeInvitationIdentifierSchema,
+  company: CompanyIdentifierSchema,
+  status: EmployeeInvitationStatusSchema.meta({ description: "The status of the invitation. This can be used to determine if the invitation is still pending, if it has been accepted by the employee, if it has been revoked by an admin, or if it has been rejected by the employee." }),
+  email: z.email().meta({ description: "The email of the invited employee. This is the email that the invitation was sent to, and that the employee will use to accept the invitation and create their account." }),
+  role: EmployeeRoleSchema.meta({ description: "The role that the invited employee will have in the company. This can be used to determine what permissions and access the employee will have once they accept the invitation." }),
+  validUntil: z.string().meta({ description: "The date until the invitation is valid. After this date, the invitation can no longer be accepted by the employee." })
+});
+const EmployeeIssuedInvitationSchema = EmployeeInvitationSchema.extend({
+  securityToken: z.string().meta({ description: "The token for the invitation. This is used to accept the invitation and should be kept secret." })
+});
+const EmployeeInvitationPaginatedListSchema = createPaginatedResponseSchema(EmployeeInvitationSchema).extend({
+  identifier: EmployeeInvitationSearchIdentifierSchema
+});
+export {
+  EmployeeInvitationPaginatedListSchema,
+  EmployeeInvitationSchema,
+  EmployeeIssuedInvitationSchema
+};

package/schemas/models/employee.model.js

@@ -0,0 +1,20 @@
+import * as z from "zod";
+import { createPaginatedResponseSchema } from "./base.model.js";
+import { IdentityIdentifierSchema, EmployeeRoleSchema, CompanyIdentifierSchema, EmployeeSearchIdentifierSchema } from "./identifiers.model.js";
+import { MonetaryAmountSchema } from "./price.model.js";
+const EmployeeSchema = z.looseObject({
+  identifier: IdentityIdentifierSchema,
+  company: CompanyIdentifierSchema,
+  firstName: z.string().optional().meta({ description: "The first name of the employee. This is the human readable name that will be displayed in the UI." }),
+  lastName: z.string().optional().meta({ description: "The last name of the employee. This is the human readable name that will be displayed in the UI." }),
+  email: z.email().meta({ description: "The email of the employee. This is the email that the employee uses to log in and access the storefront." }),
+  role: EmployeeRoleSchema.meta({ description: "The role of the employee in the company. This can be used to determine what permissions and access the employee has in the storefront." }),
+  spendingLimit: MonetaryAmountSchema.optional().meta({ description: "The spending limit for the employee. This can be used to restrict the amount of money the employee can spend when placing orders on behalf of the company." })
+});
+const EmployeePaginatedListSchema = createPaginatedResponseSchema(EmployeeSchema).extend({
+  identifier: EmployeeSearchIdentifierSchema
+});
+export {
+  EmployeePaginatedListSchema,
+  EmployeeSchema
+};

package/schemas/models/identifiers.model.js

@@ -3,6 +3,9 @@ import { PaginationOptionsSchema } from "./base.model.js";
 const OrderStatusSchema = z.enum(["AwaitingPayment", "ReleasedToFulfillment", "Shipped", "Cancelled"]).meta({ description: "The current status of the order." });
 const OrderInventoryStatusSchema = z.enum(["NotAllocated", "Allocated", "Backordered", "Preordered"]).meta({ description: "The inventory release status of the order." });
 const ProductListTypeSchema = z.enum(["favorite", "wish", "requisition", "shopping"]).meta({ description: 'The type of product list, e.g., "wish" or "favorite".' });
+const EmployeeRoleSchema = z.enum(["admin", "manager", "employee"]);
+const EmployeeInvitationStatusSchema = z.enum(["invited", "accepted", "revoked", "rejected"]);
+const CompanyRegistrationRequestApprovalStatusSchema = z.enum(["pending", "approved", "denied"]);
 const FacetIdentifierSchema = z.looseObject({
   key: z.string()
 });
@@ -135,6 +138,38 @@ const ProductListItemIdentifierSchema = z.looseObject({
 const PromotionIdentifierSchema = z.looseObject({
   key: z.string().meta({ description: "The unique identifier for the promotion." })
 });
+const CompanyIdentifierSchema = z.looseObject({
+  /**
+   * VAT identifier, used for tax-calculation purposes
+   */
+  taxIdentifier: z.string().meta({ description: "The unique identifier for the company. Could technically also be the DUNS identifier" })
+});
+const CompanyRegistrationRequestIdentifierSchema = z.looseObject({
+  key: z.string().meta({ description: "The unique identifier for the company registration request." })
+});
+const EmployeeInvitationIdentifierSchema = z.looseObject({
+  key: z.string().meta({ description: "The unique identifier for the company employee invitation." })
+});
+const EmployeeIdentifierSchema = z.looseObject({
+  user: IdentityIdentifierSchema,
+  company: CompanyIdentifierSchema
+});
+const CompanySearchIdentifierSchema = z.looseObject({
+  paginationOptions: PaginationOptionsSchema.meta({ description: "Pagination options for the search results." })
+});
+const EmployeeInvitationSearchIdentifierSchema = z.looseObject({
+  company: CompanyIdentifierSchema.optional().meta({ description: "The identifier for the company to search employee invitations within." }),
+  email: z.email().optional().meta({ description: "The email of the invited employee to search for." }),
+  paginationOptions: PaginationOptionsSchema.meta({ description: "Pagination options for the search results." })
+});
+const EmployeeSearchIdentifierSchema = z.looseObject({
+  company: CompanyIdentifierSchema.meta({ description: "The identifier for the company to search employees within." }),
+  email: z.email().optional().meta({ description: "The email of the employee to search for." }),
+  firstName: z.string().optional().meta({ description: "The first name of the employee to search for." }),
+  lastName: z.string().optional().meta({ description: "The last name of the employee to search for." }),
+  role: EmployeeRoleSchema.optional().meta({ description: "The role of the employee to search for." }),
+  paginationOptions: PaginationOptionsSchema.meta({ description: "Pagination options for the search results." })
+});
 export {
   AddressIdentifierSchema,
   CartIdentifierSchema,
@@ -142,6 +177,16 @@ export {
   CategoryIdentifierSchema,
   CheckoutIdentifierSchema,
   CheckoutItemIdentifierSchema,
+  CompanyIdentifierSchema,
+  CompanyRegistrationRequestApprovalStatusSchema,
+  CompanyRegistrationRequestIdentifierSchema,
+  CompanySearchIdentifierSchema,
+  EmployeeIdentifierSchema,
+  EmployeeInvitationIdentifierSchema,
+  EmployeeInvitationSearchIdentifierSchema,
+  EmployeeInvitationStatusSchema,
+  EmployeeRoleSchema,
+  EmployeeSearchIdentifierSchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
   FulfillmentCenterIdentifierSchema,

package/schemas/models/index.js

@@ -22,3 +22,7 @@ export * from "./order-search.model.js";
 export * from "./product-recommendations.model.js";
 export * from "./product-associations.model.js";
 export * from "./product-list.model.js";
+export * from "./company.model.js";
+export * from "./company-registration.model.js";
+export * from "./employee.model.js";
+export * from "./employee-invitation.model.js";

package/schemas/mutations/company-registration.mutation.js

@@ -0,0 +1,14 @@
+import * as z from "zod";
+import { PointOfContactSchema } from "../models/base.model.js";
+import { AddressSchema } from "../models/profile.model.js";
+const CompanyRegistrationMutationRegisterSchema = z.object({
+  taxIdentifier: z.string().meta({ description: "The unique identifier for the company. Could technically also be the DUNS identifier" }),
+  dunsIdentifier: z.string().optional().meta({ description: "The DUNS number of the company. This is a unique identifier for businesses that can be used for credit reporting and other purposes." }),
+  tinIdentifier: z.string().optional().meta({ description: "The TIN (Tax Identification Number) of the company. This is a unique identifier for tax purposes." }),
+  name: z.string().meta({ description: "The name of the company. This is the human readable name that will be displayed in the UI." }),
+  pointOfContact: PointOfContactSchema.meta({ description: "Email and optional phone for the CFO / signatory of the company" }),
+  billingAddress: AddressSchema.meta({ description: "The billing address for this company. Not user editable." })
+});
+export {
+  CompanyRegistrationMutationRegisterSchema
+};

package/schemas/mutations/company.mutation.js

@@ -0,0 +1,30 @@
+import { AddressIdentifierSchema, CompanyIdentifierSchema } from "../models/identifiers.model.js";
+import { AddressSchema } from "../models/profile.model.js";
+import { BaseMutationSchema } from "./base.mutation.js";
+const CompanyMutationAddShippingAddressSchema = BaseMutationSchema.extend({
+  company: CompanyIdentifierSchema,
+  address: AddressSchema
+});
+const CompanyMutationRemoveShippingAddressSchema = BaseMutationSchema.extend({
+  company: CompanyIdentifierSchema,
+  addressIdentifier: AddressIdentifierSchema
+});
+const CompanyMutationUpdateShippingAddressSchema = BaseMutationSchema.extend({
+  company: CompanyIdentifierSchema,
+  address: AddressSchema
+});
+const CompanyMutationMakeShippingAddressDefaultSchema = BaseMutationSchema.extend({
+  company: CompanyIdentifierSchema,
+  addressIdentifier: AddressIdentifierSchema
+});
+const CompanyMutationSetBillingAddressSchema = BaseMutationSchema.extend({
+  company: CompanyIdentifierSchema,
+  address: AddressSchema
+});
+export {
+  CompanyMutationAddShippingAddressSchema,
+  CompanyMutationMakeShippingAddressDefaultSchema,
+  CompanyMutationRemoveShippingAddressSchema,
+  CompanyMutationSetBillingAddressSchema,
+  CompanyMutationUpdateShippingAddressSchema
+};

package/schemas/mutations/employee-invitation.mutation.js

@@ -0,0 +1,20 @@
+import * as z from "zod";
+import { EmployeeInvitationIdentifierSchema, EmployeeRoleSchema, CompanyIdentifierSchema } from "../models/identifiers.model.js";
+const EmployeeInvitationMutationInviteEmployeeSchema = z.object({
+  company: CompanyIdentifierSchema,
+  email: z.email().meta({ description: "The email of the invited employee. This is the email that the invitation will be sent to, and that the employee will use to accept the invitation and create their account." }),
+  role: EmployeeRoleSchema.meta({ description: "The role that the invited employee will have in the company. This can be used to determine what permissions and access the employee will have once they accept the invitation." })
+});
+const EmployeeInvitationMutationAcceptInvitationSchema = z.object({
+  invitationIdentifier: EmployeeInvitationIdentifierSchema,
+  securityToken: z.string().meta({ description: "The security token for accepting the invitation. This is used to verify that the person accepting the invitation has access to the email it was sent to." }),
+  currentUserEmail: z.email().meta({ description: "The email of the employee accepting the invitation. This is used to verify that the person accepting the invitation is the same as the one it was sent to." })
+});
+const EmployeeInvitationMutationRevokeInvitationSchema = z.object({
+  invitationIdentifier: EmployeeInvitationIdentifierSchema
+});
+export {
+  EmployeeInvitationMutationAcceptInvitationSchema,
+  EmployeeInvitationMutationInviteEmployeeSchema,
+  EmployeeInvitationMutationRevokeInvitationSchema
+};

package/schemas/mutations/employee.mutation.js

@@ -0,0 +1,29 @@
+import * as z from "zod";
+import {
+  IdentityIdentifierSchema,
+  EmployeeRoleSchema,
+  CompanyIdentifierSchema
+} from "../models/identifiers.model.js";
+const EmployeeMutationAssignRoleSchema = z.object({
+  company: CompanyIdentifierSchema,
+  employeeIdentifier: IdentityIdentifierSchema,
+  role: EmployeeRoleSchema.meta({
+    description: "The role to assign to the employee. This can be used to determine what permissions and access the employee will have in the storefront."
+  })
+});
+const EmployeeMutationUnassignRoleSchema = z.object({
+  company: CompanyIdentifierSchema,
+  employeeIdentifier: IdentityIdentifierSchema,
+  role: EmployeeRoleSchema.meta({
+    description: "The role to unassign from the employee. This can be used to determine what permissions and access the employee will have in the storefront."
+  })
+});
+const EmployeeMutationRemoveEmployeeSchema = z.object({
+  company: CompanyIdentifierSchema,
+  employeeIdentifier: IdentityIdentifierSchema
+});
+export {
+  EmployeeMutationAssignRoleSchema,
+  EmployeeMutationRemoveEmployeeSchema,
+  EmployeeMutationUnassignRoleSchema
+};

package/schemas/mutations/index.js

@@ -9,3 +9,7 @@ export * from "./product-reviews.mutation.js";
 export * from "./profile.mutation.js";
 export * from "./search.mutation.js";
 export * from "./checkout.mutation.js";
+export * from "./company-registration.mutation.js";
+export * from "./employee.mutation.js";
+export * from "./employee-invitation.mutation.js";
+export * from "./company.mutation.js";

package/schemas/queries/checkout.query.js

@@ -1,5 +1,5 @@
-import { BaseQuerySchema } from "./base.query.js";
 import { CheckoutIdentifierSchema } from "../models/identifiers.model.js";
+import { BaseQuerySchema } from "./base.query.js";
 const CheckoutQueryByIdSchema = BaseQuerySchema.extend({
   identifier: CheckoutIdentifierSchema
 });

package/schemas/queries/company-registration.query.js

@@ -0,0 +1,8 @@
+import * as z from "zod";
+import { CompanyRegistrationRequestIdentifierSchema } from "../models/identifiers.model.js";
+const CompanyRegistrationQueryCheckRegistrationStatusSchema = z.object({
+  requestIdentifier: CompanyRegistrationRequestIdentifierSchema
+});
+export {
+  CompanyRegistrationQueryCheckRegistrationStatusSchema
+};

package/schemas/queries/company.query.js

@@ -0,0 +1,12 @@
+import { CompanyIdentifierSchema, CompanySearchIdentifierSchema } from "../models/identifiers.model.js";
+import { BaseQuerySchema } from "./base.query.js";
+const CompanyQueryByIdSchema = BaseQuerySchema.extend({
+  identifier: CompanyIdentifierSchema
+});
+const CompanyQueryListSchema = BaseQuerySchema.extend({
+  search: CompanySearchIdentifierSchema
+});
+export {
+  CompanyQueryByIdSchema,
+  CompanyQueryListSchema
+};

package/schemas/queries/employee-invitation.query.js

@@ -0,0 +1,8 @@
+import { EmployeeInvitationSearchIdentifierSchema } from "../models/identifiers.model.js";
+import { BaseQuerySchema } from "./base.query.js";
+const EmployeeInvitationQueryListSchema = BaseQuerySchema.extend({
+  search: EmployeeInvitationSearchIdentifierSchema
+});
+export {
+  EmployeeInvitationQueryListSchema
+};

package/schemas/queries/employee.query.js

@@ -0,0 +1,19 @@
+import * as z from "zod";
+import { BaseQuerySchema } from "./base.query.js";
+import {
+  CompanyIdentifierSchema,
+  EmployeeSearchIdentifierSchema
+} from "../models/identifiers.model.js";
+const EmployeeQueryListSchema = BaseQuerySchema.extend({
+  search: EmployeeSearchIdentifierSchema
+});
+const EmployeeQueryByEmailSchema = BaseQuerySchema.extend({
+  company: CompanyIdentifierSchema,
+  email: z.email().meta({
+    description: "The email of the employee to fetch. This can be used to fetch a specific employee by their email address, which is often a unique identifier for users in the system."
+  })
+});
+export {
+  EmployeeQueryByEmailSchema,
+  EmployeeQueryListSchema
+};

package/schemas/queries/index.js

@@ -16,3 +16,7 @@ export * from "./order-search.query.js";
 export * from "./product-recommendations.query.js";
 export * from "./product-associations.query.js";
 export * from "./product-list.query.js";
+export * from "./company-registration.query.js";
+export * from "./employee.query.js";
+export * from "./employee-invitation.query.js";
+export * from "./company.query.js";

package/schemas/queries/product-associations.query.js

@@ -1,7 +1,6 @@
 import * as z from "zod";
+import { ProductIdentifierSchema } from "../models/identifiers.model.js";
 import { BaseQuerySchema } from "./base.query.js";
-import { ProductIdentifierSchema, ProductVariantIdentifierSchema } from "../models/identifiers.model.js";
-import { CartItemSchema } from "../models/cart.model.js";
 const ProductAssociationsGetAccessoriesQuerySchema = BaseQuerySchema.extend({
   forProduct: ProductIdentifierSchema.describe("The product identifier for which to get accessory recommendations. The provider should return recommendations that are relevant to this product, e.g., products that are frequently bought together, products that are similar in style or category, or products that are popular among users with similar preferences."),
   numberOfAccessories: z.number().min(1).max(12).meta({ description: "The number of accessory recommendations requested. The provider may return fewer than this number, but should not return more." })

package/schemas/queries/product-reviews.query.js

@@ -1,6 +1,5 @@
-import * as z from "zod";
-import { BaseQuerySchema } from "./base.query.js";
 import { PaginationOptionsSchema, ProductIdentifierSchema } from "../models/index.js";
+import { BaseQuerySchema } from "./base.query.js";
 const ProductReviewsListQuerySchema = BaseQuerySchema.extend({
   product: ProductIdentifierSchema.meta({ description: "The product to list reviews for." }),
   paginationOptions: PaginationOptionsSchema.optional().meta({ description: "Optional pagination options for the review list." })

package/schemas/queries/profile.query.js

@@ -1,5 +1,5 @@
-import { BaseQuerySchema } from "./base.query.js";
 import { IdentityIdentifierSchema } from "../models/identifiers.model.js";
+import { BaseQuerySchema } from "./base.query.js";
 const ProfileQueryByIdSchema = BaseQuerySchema.extend({
   identifier: IdentityIdentifierSchema
 });

package/schemas/session.schema.js

@@ -25,6 +25,7 @@ const RequestContextSchema = z.looseObject({
   languageContext: LanguageContextSchema.default(() => LanguageContextSchema.parse({})).describe("ReadOnly. The language and locale context for the current request."),
   storeIdentifier: WebStoreIdentifierSchema.default(() => WebStoreIdentifierSchema.parse({})).describe("ReadOnly. The identifier of the current web store making the request."),
   taxJurisdiction: TaxJurisdictionSchema.default(() => TaxJurisdictionSchema.parse({})).describe("ReadOnly. The tax jurisdiction for the current request, typically derived from the store location or carts billing address"),
+  companyIdentifier: z.string().optional().meta({ description: "The company associated with the request, if applicable. This can be used to segment requests and apply different logic or rules based on the business unit." }),
   correlationId: z.string().default("").meta({ description: "A unique identifier for the request, can be used for tracing and logging purposes." }),
   isBot: z.boolean().default(false).meta({ description: "Indicates if the request is made by a bot or crawler." }),
   clientIp: z.string().default("").meta({ description: "The IP address of the client making the request, if available. Mostly for logging purposes" }),