@reactionary/source 0.0.41 → 0.0.48

package/core/src/schemas/models/identifiers.model.ts

@@ -1,61 +1,96 @@
 import { z } from 'zod';
 
 export const FacetIdentifierSchema = z.looseObject({
-    key: z.string().default('').nonoptional()
+  key: z.string().default('').nonoptional(),
 });
 
 export const FacetValueIdentifierSchema = z.looseObject({
-    facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
-    key: z.string().default('')
+  facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+  key: z.string().default(''),
 });
 
 export const SKUIdentifierSchema = z.looseObject({
-    key: z.string().default('').nonoptional()
+  key: z.string().default('').nonoptional(),
 });
 
 export const ProductIdentifierSchema = z.looseObject({
-    key: z.string().default(''),
+  key: z.string().default(''),
 });
 
 export const SearchIdentifierSchema = z.looseObject({
-    term: z.string().default(''),
-    page: z.number().default(0),
-    pageSize: z.number().default(20),
-    facets: z.array(FacetValueIdentifierSchema.required()).default(() => [])
+  term: z.string().default(''),
+  page: z.number().default(0),
+  pageSize: z.number().default(20),
+  facets: z.array(FacetValueIdentifierSchema.required()).default(() => []),
 });
 
 export const CartIdentifierSchema = z.looseObject({
-    key: z.string().default('')
+  key: z.string().default(''),
 });
 
 export const CartItemIdentifierSchema = z.looseObject({
-    key: z.string().default('')
+  key: z.string().default(''),
 });
 
 export const PriceIdentifierSchema = z.looseObject({
-    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
 });
 
 export const CategoryIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional()
+  key: z.string().default('').nonoptional(),
+});
+
+export const StoreIdentifierSchema = z.looseObject({
+  key: z.string().default('').optional(),
+});
+
+export const OrderIdentifierSchema = z.looseObject({
+  key: z.string().default('').nonoptional(),
+});
+
+export const OrderItemIdentifierSchema = z.looseObject({
+  key: z.string().default('').nonoptional(),
 });
 
 /**
  * The target store the user is interacting with. Can change over time, and is not necessarily the same as the default store.
  */
 export const WebStoreIdentifierSchema = z.looseObject({
-    key: z.string().default('').nonoptional()
+  key: z.string().default('').nonoptional(),
 });
 
-export const InventoryChannelIdentifierSchema= z.looseObject({
-    key: z.string().default('online').nonoptional()
+export const FulfillmentCenterIdentifierSchema = z.looseObject({
+  key: z.string().default('').nonoptional(),
 });
 
 export const InventoryIdentifierSchema = z.looseObject({
-    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
-    channelId: InventoryChannelIdentifierSchema.default(() => InventoryChannelIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+  fulfillmentCenter: FulfillmentCenterIdentifierSchema.default(() =>
+    FulfillmentCenterIdentifierSchema.parse({})
+  ),
+});
+
+export const IdentityIdentifierSchema = z.looseObject({
+  userId: z.string().default('').nonoptional(),
 });
 
+export const ShippingMethodIdentifierSchema = z.looseObject({
+  key: z.string().default('').nonoptional(),
+});
+
+export const PaymentMethodIdentifierSchema = z.looseObject({
+  method: z.string().default('').nonoptional(),
+  name: z.string().default('').nonoptional(),
+  paymentProcessor: z.string().default('').nonoptional(),
+});
+
+export const AddressIdentifierSchema = z.looseObject({
+  nickName: z.string().default('').nonoptional(),
+});
+
+export const PaymentInstructionIdentifierSchema = z.looseObject({
+  key: z.string().default('').nonoptional(),
+});
 
 export type ProductIdentifier = z.infer<typeof ProductIdentifierSchema>;
 export type SearchIdentifier = z.infer<typeof SearchIdentifierSchema>;
@@ -67,7 +102,40 @@ export type PriceIdentifier = z.infer<typeof PriceIdentifierSchema>;
 export type CategoryIdentifier = z.infer<typeof CategoryIdentifierSchema>;
 export type WebStoreIdentifier = z.infer<typeof WebStoreIdentifierSchema>;
 export type InventoryIdentifier = z.infer<typeof InventoryIdentifierSchema>;
-export type InventoryChannelIdentifier = z.infer<typeof InventoryChannelIdentifierSchema>;
-
-
-export type IdentifierType = ProductIdentifier | SearchIdentifier | FacetIdentifier | FacetValueIdentifier | CartIdentifier | CartItemIdentifier | PriceIdentifier | CategoryIdentifier | WebStoreIdentifier | InventoryIdentifier;
+export type FulfillmentCenterIdentifier = z.infer<
+  typeof FulfillmentCenterIdentifierSchema
+>;
+export type IdentityIdentifier = z.infer<typeof IdentityIdentifierSchema>;
+export type ShippingMethodIdentifier = z.infer<
+  typeof ShippingMethodIdentifierSchema
+>;
+export type PaymentMethodIdentifier = z.infer<
+  typeof PaymentMethodIdentifierSchema
+>;
+export type AddressIdentifier = z.infer<typeof AddressIdentifierSchema>;
+export type PaymentInstructionIdentifier = z.infer<
+  typeof PaymentInstructionIdentifierSchema
+>;
+export type OrderIdentifier = z.infer<typeof OrderIdentifierSchema>;
+export type OrderItemIdentifier = z.infer<typeof OrderItemIdentifierSchema>;
+export type StoreIdentifier = z.infer<typeof StoreIdentifierSchema>;
+
+export type IdentifierType =
+  | ProductIdentifier
+  | SearchIdentifier
+  | FacetIdentifier
+  | FacetValueIdentifier
+  | CartIdentifier
+  | CartItemIdentifier
+  | PriceIdentifier
+  | CategoryIdentifier
+  | WebStoreIdentifier
+  | InventoryIdentifier
+  | FulfillmentCenterIdentifier
+  | IdentityIdentifier
+  | ShippingMethodIdentifier
+  | PaymentMethodIdentifier
+  | AddressIdentifier
+  | PaymentInstructionIdentifier
+  | OrderIdentifier
+  | OrderItemIdentifier;

package/core/src/schemas/models/identity.model.ts

@@ -1,15 +1,31 @@
 import { z } from 'zod';
 import { BaseModelSchema } from './base.model';
+import { IdentityIdentifierSchema } from './identifiers.model';
 
-export const IdentityTypeSchema = z.enum(["Anonymous", "Guest", "Registered"]);
+export const AnonymousIdentitySchema = BaseModelSchema.extend({
+    type: z.literal('Anonymous')
+});
+
+export const GuestIdentitySchema = BaseModelSchema.extend({
+    id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+    type: z.literal('Guest'),
+    token: z.string().optional(),
+    refresh_token: z.string().optional(),
+    expiry: z.coerce.date().default(new Date())
+});
 
-export const IdentitySchema = BaseModelSchema.extend({
-    id: z.string().default(''),
-    type: IdentityTypeSchema.default("Anonymous"),
+export const RegisteredIdentitySchema = BaseModelSchema.extend({
+    id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+    type: z.literal('Registered'),
+    logonId: z.string().default(''),
     token: z.string().optional(),
-    issued: z.coerce.date().default(new Date()),
+    refresh_token: z.string().optional(),
     expiry: z.coerce.date().default(new Date())
 });
 
-export type IdentityType = z.infer<typeof IdentityTypeSchema>;
-export type Identity = z.infer<typeof IdentitySchema>;
+export const IdentitySchema = z.discriminatedUnion('type', [ AnonymousIdentitySchema, GuestIdentitySchema, RegisteredIdentitySchema]);
+
+export type AnonymousIdentity = z.infer<typeof AnonymousIdentitySchema>;
+export type GuestIdentity = z.infer<typeof GuestIdentitySchema>;
+export type RegisteredIdentity = z.infer<typeof RegisteredIdentitySchema>;
+export type Identity = z.infer<typeof IdentitySchema>;

package/core/src/schemas/models/index.ts

@@ -0,0 +1,15 @@
+export * from './analytics.model';
+export * from './base.model';
+export * from './cart.model';
+export * from './category.model';
+export * from './currency.model';
+export * from './identifiers.model';
+export * from './identity.model';
+export * from './inventory.model';
+export * from './payment.model';
+export * from './price.model';
+export * from './product.model';
+export * from './profile.model';
+export * from './search.model';
+export * from './shipping-method.model';
+export * from './store.model';

package/core/src/schemas/models/payment.model.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { BaseModelSchema, ImageSchema } from './base.model';
+import { CartIdentifierSchema, InventoryIdentifierSchema, PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from './identifiers.model';
+import { MonetaryAmountSchema } from './price.model';
+import { describe } from 'node:test';
+
+export const PaymentStatusSchema = z.enum(['pending', 'authorized', 'canceled', 'capture', 'partial_capture', 'refunded', 'partial_refund']);
+
+export const PaymentProtocolDataSchema = z.looseObject({
+    key: z.string().default(''),
+    value: z.string().default(''),
+});
+
+
+export const PaymentMethodSchema = BaseModelSchema.extend({
+    identifier: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+    logo: ImageSchema.optional(),
+    description: z.string().default(''),
+    isPunchOut: z.boolean().default(true)
+});
+
+export const PaymentInstructionSchema = BaseModelSchema.extend({
+    identifier: PaymentInstructionIdentifierSchema.default(() => PaymentInstructionIdentifierSchema.parse({})),
+    amount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
+    paymentMethod: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+    protocolData: z.array(PaymentProtocolDataSchema).default(() => []).describe('Additional protocol-specific data for processing the payment.'),
+    status: PaymentStatusSchema.default('pending'),
+});
+
+export const CartPaymentInstructionSchema = PaymentInstructionSchema.extend({
+    cart: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({}))
+});
+
+export const OrderPaymentInstructionSchema = PaymentInstructionSchema.extend({
+    order: z.string().default('') // OrderIdentifierSchema
+});
+
+export type CartPaymentInstruction = z.infer<typeof CartPaymentInstructionSchema>;
+export type OrderPaymentInstruction = z.infer<typeof OrderPaymentInstructionSchema>;
+export type PaymentInstruction = z.infer<typeof PaymentInstructionSchema>;
+export type PaymentStatus = z.infer<typeof PaymentStatusSchema>;

package/core/src/schemas/models/profile.model.ts

@@ -0,0 +1,35 @@
+import z from "zod";
+import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model";
+import { BaseModelSchema } from "./base.model";
+
+export const AddressSchema = BaseModelSchema.extend({
+    identifier: AddressIdentifierSchema.default(() => AddressIdentifierSchema.parse({})),
+    firstName: z.string().default(''),
+    lastName: z.string().default(''),
+    streetAddress: z.string().default(''),
+    streetNumber: z.string().default(''),
+    city: z.string().default(''),
+    region: z.string().default(''),
+    postalCode: z.string().default(''),
+    countryCode: z.string().default('US'),
+});
+
+export const ProfileSchema = BaseModelSchema.extend({
+    identifier: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+    email: z.string().email().default(''),
+    phone: z.string().default(''),
+
+    emailVerified: z.boolean().default(false),
+    phoneVerified: z.boolean().default(false),
+
+    createdAt: z.string().default(() => new Date().toISOString()),
+    updatedAt: z.string().default(() => new Date().toISOString()),
+
+    shippingAddress: AddressSchema.optional(),
+    billingAddress: AddressSchema.optional(),
+
+    alternateShippingAddresses: z.array(AddressSchema).default(() => []),
+});
+
+export type Address = z.infer<typeof AddressSchema>;
+export type Profile = z.infer<typeof ProfileSchema>;

package/core/src/schemas/models/shipping-method.model.ts

@@ -0,0 +1,14 @@
+import z from "zod";
+import { ShippingMethodIdentifierSchema } from "./identifiers.model";
+import { MonetaryAmountSchema } from "./price.model";
+import { ImageSchema } from "./base.model";
+
+export const ShippingMethodSchema = z.looseObject({
+    identifier: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
+    name: z.string().default(''),
+    description: z.string().default(''),
+    logo: ImageSchema.optional(),
+    price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
+    deliveryTime: z.string().default(''),
+});
+

package/core/src/schemas/models/store.model.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { BaseModelSchema } from './base.model';
+import { FulfillmentCenterIdentifierSchema, StoreIdentifierSchema } from './identifiers.model';
+
+export const StoreSchema = BaseModelSchema.extend({
+    identifier: StoreIdentifierSchema.default(() => StoreIdentifierSchema.parse({})),
+    name: z.string().default(''),
+    fulfillmentCenter: FulfillmentCenterIdentifierSchema.default(() => FulfillmentCenterIdentifierSchema.parse({}))
+});
+
+export type Store = z.infer<typeof StoreSchema>;

package/core/src/schemas/mutations/cart-payment.mutation.ts

@@ -0,0 +1,21 @@
+import type z from "zod";
+import { CartIdentifierSchema, PaymentInstructionIdentifierSchema } from "../models/identifiers.model";
+import { PaymentInstructionSchema } from "../models/payment.model";
+import { BaseMutationSchema } from "./base.mutation";
+
+
+
+export const CartPaymentMutationAddPayment = BaseMutationSchema.extend({
+    paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+    cart: CartIdentifierSchema.required()
+});
+
+export const CartPaymentMutationCancelPayment = BaseMutationSchema.extend({
+    paymentInstruction: PaymentInstructionIdentifierSchema.required(),
+    cart: CartIdentifierSchema.required()
+});
+
+
+
+export type CartPaymentMutationAddPayment = z.infer<typeof CartPaymentMutationAddPayment>;
+export type CartPaymentMutationCancelPayment = z.infer<typeof CartPaymentMutationCancelPayment>;

package/core/src/schemas/mutations/cart.mutation.ts

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 import { BaseMutationSchema } from './base.mutation';
-import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
+import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifierSchema, SKUIdentifierSchema } from '../models/identifiers.model';
+import { AddressSchema } from '../models/profile.model';
+import { CurrencySchema } from '../models/currency.model';
+import { MonetaryAmountSchema } from '../models/price.model';
 
 export const CartMutationItemAddSchema = BaseMutationSchema.extend({
     cart: CartIdentifierSchema.nonoptional(),
-    product: ProductIdentifierSchema.nonoptional(),
+    sku: SKUIdentifierSchema.nonoptional(),
     quantity: z.number()
 });
 
@@ -19,6 +22,62 @@ export const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
     quantity: z.number()
 });
 
+export const CartMutationDeleteCartSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required()
+});
+
+export const CartMutationSetShippingInfoSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    shippingMethod: ShippingMethodIdentifierSchema.optional(),
+    shippingAddress: AddressSchema.optional(),
+});
+
+export const CartMutationSetBillingAddressSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    billingAddress: AddressSchema.required(),
+    notificationEmailAddress: z.string().optional(),
+    notificationPhoneNumber: z.string().optional(),
+});
+
+export const CartMutationApplyCouponSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    couponCode: z.string().default('').nonoptional()
+});
+
+export const CartMutationRemoveCouponSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    couponCode: z.string().default('').nonoptional()
+});
+
+export const CartMutationCheckoutSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required()
+});
+
+export const CartMutationAddPaymentMethodSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    paymentMethodId: PaymentMethodIdentifierSchema.required(),
+    amount: MonetaryAmountSchema.optional().describe('The amount to authorize for the payment method. If not provided, the full remaining balance of the cart will be authorized.')
+});
+
+export const CartMutationRemovePaymentMethodSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+});
+
+export const CartMutationChangeCurrencySchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    newCurrency: CurrencySchema.default(() => CurrencySchema.parse({})).describe('The new currency to set for the cart.')
+});
+
+
+export type CartMutationChangeCurrency = z.infer<typeof CartMutationChangeCurrencySchema>;
+export type CartMutationAddPaymentMethod = z.infer<typeof CartMutationAddPaymentMethodSchema>;
+export type CartMutationRemovePaymentMethod = z.infer<typeof CartMutationRemovePaymentMethodSchema>;
+export type CartMutationCheckout = z.infer<typeof CartMutationCheckoutSchema>;
 export type CartMutationItemAdd = z.infer<typeof CartMutationItemAddSchema>;
 export type CartMutationItemRemove = z.infer<typeof CartMutationItemRemoveSchema>;
-export type CartMutationItemQuantityChange = z.infer<typeof CartMutationItemQuantityChangeSchema>;
+export type CartMutationItemQuantityChange = z.infer<typeof CartMutationItemQuantityChangeSchema>;
+export type CartMutationDeleteCart = z.infer<typeof CartMutationDeleteCartSchema>;
+export type CartMutationSetShippingInfo = z.infer<typeof CartMutationSetShippingInfoSchema>;
+export type CartMutationSetBillingAddress = z.infer<typeof CartMutationSetBillingAddressSchema>;
+export type CartMutationApplyCoupon = z.infer<typeof CartMutationApplyCouponSchema>;
+export type CartMutationRemoveCoupon = z.infer<typeof CartMutationRemoveCouponSchema>;

package/core/src/schemas/mutations/identity.mutation.ts

@@ -9,5 +9,12 @@ export const IdentityMutationLoginSchema = BaseMutationSchema.extend({
 export const IdentityMutationLogoutSchema = BaseMutationSchema.extend({
 });
 
+export const IdentityMutationRegisterSchema = BaseMutationSchema.extend({
+    username: z.string(),
+    password: z.string()
+});
+
+
 export type IdentityMutationLogin = z.infer<typeof IdentityMutationLoginSchema>;
-export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;
+export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;
+export type IdentityMutationRegister = z.infer<typeof IdentityMutationRegisterSchema>;

package/core/src/schemas/mutations/index.ts

@@ -0,0 +1,10 @@
+export * from './analytics.mutation';
+export * from './base.mutation';
+export * from './cart-payment.mutation';
+export * from './cart.mutation';
+export * from './identity.mutation';
+export * from './inventory.mutation';
+export * from './price.mutation';
+export * from './product.mutation';
+export * from './profile.mutation';
+export * from './search.mutation';

package/core/src/schemas/mutations/profile.mutation.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { BaseMutationSchema } from './base.mutation';
+
+export const ProfileMutationUpdateSchema = BaseMutationSchema.extend({
+    email: z.email().default('base@example.com'),
+    phone: z.string().default(''),
+});
+
+export type ProfileMutationUpdate = z.infer<typeof ProfileMutationUpdateSchema>;

package/core/src/schemas/queries/cart-payment.query.ts

@@ -0,0 +1,12 @@
+import z from "zod";
+import { CartIdentifierSchema } from "../models/identifiers.model";
+import { PaymentStatusSchema } from "../models/payment.model";
+import { BaseQuerySchema } from "./base.query";
+
+
+export const CartPaymentQueryByCartSchema = BaseQuerySchema.extend({
+    cart: CartIdentifierSchema.required(),
+    status: z.array(PaymentStatusSchema).optional().describe('Optional status to filter payment instructions by'),
+});
+
+export type CartPaymentQueryByCart = z.infer<typeof CartPaymentQueryByCartSchema>;

package/core/src/schemas/queries/cart.query.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
 import { CartIdentifierSchema } from '../models/identifiers.model';
 

package/core/src/schemas/queries/identity.query.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
 
 export const IdentityQuerySelfSchema = BaseQuerySchema.extend({

package/core/src/schemas/queries/index.ts

@@ -1,9 +1,12 @@
 export * from './analytics.query';
 export * from './base.query';
+export * from './cart-payment.query';
 export * from './cart.query';
 export * from './category.query';
 export * from './identity.query';
 export * from './inventory.query';
 export * from './price.query';
 export * from './product.query';
+export * from './profile.query';
 export * from './search.query';
+export * from './store.query';

package/core/src/schemas/queries/inventory.query.ts

@@ -1,19 +1,11 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
-import { ProductIdentifier, ProductIdentifierSchema } from '../models/identifiers.model';
+import { FulfillmentCenterIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
 
 export const InventoryQueryBySKUSchema = BaseQuerySchema.extend({
-    query: z.literal('sku'),
-    sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+    sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})).nonoptional(),
+    fulfilmentCenter: FulfillmentCenterIdentifierSchema.default(() => FulfillmentCenterIdentifierSchema.parse({})).nonoptional()
 });
 
 //export type InventoryQuery = z.infer<typeof InventoryQuerySchema>;
 export type InventoryQueryBySKU = z.infer<typeof InventoryQueryBySKUSchema>;
-
-export interface  InventoryQueries {
-  "sku": { sku: ProductIdentifier }
-};
-
-export type InventoryQuery = {
-  [K in keyof InventoryQueries]: { type: K } & InventoryQueries[K];
-}[keyof InventoryQueries];

package/core/src/schemas/queries/price.query.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
 import { SKUIdentifierSchema } from '../models/identifiers.model';
 

package/core/src/schemas/queries/profile.query.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+
+export const ProfileQuerySelfSchema = BaseQuerySchema.extend({
+});
+
+export type ProfileQuerySelf = z.infer<typeof ProfileQuerySelfSchema>;

package/core/src/schemas/queries/search.query.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
 import { SearchIdentifierSchema } from '../models/identifiers.model';
 

package/core/src/schemas/queries/store.query.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+
+export const StoreQueryByProximitySchema = BaseQuerySchema.extend({
+    longitude: z.number().default(0),
+    latitude: z.number().default(0),
+    distance: z.number().default(0),
+    limit: z.number().default(10)
+});
+
+export type StoreQueryByProximity = z.infer<typeof StoreQueryByProximitySchema>;

package/core/src/schemas/session.schema.ts

@@ -3,18 +3,43 @@ import { IdentitySchema } from './models/identity.model';
 import { WebStoreIdentifierSchema } from './models/identifiers.model';
 import { CurrencySchema } from './models/currency.model';
 
+/**
+ * The language and locale context for the current request.
+ */
 export const LanguageContextSchema = z.looseObject( {
     locale: z.string().default('en-US'),
     currencyCode: CurrencySchema.default(() => CurrencySchema.parse({})),
-    countryCode: z.string().default('US'),
 })
 
-export const SessionSchema = z.looseObject({
-    id: z.string(),
-    identity: IdentitySchema.default(() => IdentitySchema.parse({})),
-    languageContext: LanguageContextSchema.default(() => LanguageContextSchema.parse({})),
-    storeIdentifier: WebStoreIdentifierSchema.default(() => WebStoreIdentifierSchema.parse({})),
+export const SessionSchema = z.record( z.string(), z.any());
+
+export const TaxJurisdictionSchema = z.object( {
+    countryCode: z.string().default('US'),
+    stateCode: z.string().default(''),
+    countyCode: z.string().default(''),
+    cityCode: z.string().default(''),
 });
 
+export const RequestContextSchema = z.looseObject( {
+    identity: IdentitySchema.default(() => IdentitySchema.parse({})).describe('Read/Write. The identity of the current user. Caller is responsible for persisting any changes to the identity'),
+    session: SessionSchema.default(() => SessionSchema.parse({})).describe('Read/Write session storage. Caller is responsible for persisting any changes. Providers will prefix own values'),
+
+    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'),
+
+    correlationId: z.string().default('').describe('A unique identifier for the request, can be used for tracing and logging purposes.'),
+    isBot: z.boolean().default(false).describe('Indicates if the request is made by a bot or crawler.'),
+
+    clientIp: z.string().default('').describe('The IP address of the client making the request, if available. Mostly for logging purposes'),
+    userAgent: z.string().default('').describe('The user agent string of the client making the request, if available.'),
+    referrer: z.string().default('').describe('The referrer URL, if available.'),
+
+})
+
+
+
 export type Session = z.infer<typeof SessionSchema>;
 export type LanguageContext = z.infer<typeof LanguageContextSchema>;
+export type RequestContext = z.infer<typeof RequestContextSchema>;
+export type TaxJurisdiction = z.infer<typeof TaxJurisdictionSchema>;

package/eslint.config.mjs

@@ -27,6 +27,13 @@ export default [
           ],
         },
       ],
+      '@typescript-eslint/consistent-type-imports': [
+        'error',
+        {
+          prefer: 'type-imports',
+          fixStyle: 'separate-type-imports',
+        },
+      ],
     },
   },
   {