@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,31 +1,73 @@
 import { z } from 'zod';
-import { ProductIdentifierSchema, SKUIdentifierSchema } from './identifiers.model.js';
-import { BaseModelSchema } from './base.model.js';
-
-export const SKUSchema = z.looseObject({
-    identifier: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
-/*    name: z.string().default(''),
-    slug: z.string().default(''),
-    image: ImageSchema.default(() => ImageSchema.parse({})), */
+import { CategoryIdentifierSchema, ProductAttributeIdentifierSchema, ProductAttributeValueIdentifierSchema, ProductIdentifierSchema, ProductOptionIdentifierSchema, ProductOptionValueIdentifierSchema, ProductVariantIdentifierSchema } from './identifiers.model.js';
+import { BaseModelSchema, ImageSchema } from './base.model.js';
+import type { InferType } from '../../zod-utils.js';
+
+
+export const ProductOptionValueSchema = z.looseObject({
+  identifier: ProductOptionValueIdentifierSchema.describe('The unique identifier for the product option value.'),
+  label: z.string().describe('The human-friendly label for the product option value.'),
+});
+
+export const ProductOptionSchema = z.looseObject({
+  identifier: ProductOptionIdentifierSchema.describe('The unique identifier for the option.'),
+  name: z.string().describe('The name of the option, e.g., Size or Color.'),
+  values: z.array(ProductOptionValueSchema).describe('A list of possible values for the option.'),
 });
 
+export const ProductVariantOptionSchema = z.looseObject({
+  identifier: ProductOptionIdentifierSchema.describe('The unique identifier for the option.'),
+  name: z.string().describe('The name of the option, e.g., Size or Color.'),
+  value: ProductOptionValueSchema.describe('The unique identifier for the option value.'),
+});
+
+export const ProductVariantSchema = z.looseObject({
+    identifier: ProductVariantIdentifierSchema.describe('The unique identifier for the variant. Often its SKU'),
+    name: z.string(),
+    images: z.array(ImageSchema).describe('A list of images associated with the product variant'),
+    ean: z.string().describe('The European Article Number identifier for the product variant'),
+    gtin: z.string().describe('The Global Trade Item Number identifier for the product variant'),
+    upc: z.string().describe('The Universal Product Code identifier for the product variant'),
+    barcode: z.string().describe('The barcode identifier for the product variant'),
+    options: z.array(ProductVariantOptionSchema).describe('A list of option identifiers that define this variant'),
+});
+
+export const ProductAttributeValueSchema = z.looseObject({
+    identifier: ProductAttributeValueIdentifierSchema.describe('The unique identifier for the attribute value.'),
+    value: z.string().describe('The value of the attribute. Typically a language independent string'),
+    label: z.string().describe('The human friendly label for the attribute value. Typically a language dependent string'),
+});
+
+
+
 export const ProductAttributeSchema = z.looseObject({
-    id: z.string(),
+    identifier: ProductAttributeIdentifierSchema.describe('The unique identifier for the attribute, also typically used as the facet key if the attribute is filterable.'),
+    group: z.string(),
     name: z.string(),
-    value: z.string()
+    values: z.array(ProductAttributeValueSchema)
 });
 
 export const ProductSchema = BaseModelSchema.extend({
-    identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
-    name: z.string().default(''),
-    slug: z.string().default(''),
-    description: z.string().default(''),
-    image: z.string().url().default('https://placehold.co/400'),
-    images: z.string().url().array().default(() => []),
-    attributes: z.array(ProductAttributeSchema).default(() => []),
-    skus: z.array(SKUSchema).default(() => [])
-});
+    identifier: ProductIdentifierSchema,
+    name: z.string().describe('The name of the product'),
+    slug: z.string().describe('The URL-friendly identifier for the product'),
+    description: z.string().describe('A brief description of the product'),
+    longDescription: z.string().describe('A detailed description of the product'),
+    brand: z.string().describe('The brand associated with the product'),
+    manufacturer: z.string().describe('The manufacturer of the product'),
+    parentCategories: z.array(CategoryIdentifierSchema).describe('A list of parent categories the product belongs to'),
+    published: z.boolean().describe('Indicates whether the product is published and visible to customers'),
+    sharedAttributes: z.array(ProductAttributeSchema).describe('A list of technical attributes associated with the product'),
+    options: z.array(ProductOptionSchema).describe('A list of options available for the product, such as size or color. Can be empty if product is single-sku'),
+    mainVariant: ProductVariantSchema.describe('The primary SKU for the product'),
+    variants: z.array(ProductVariantSchema).default([]).describe('A list of all SKUs for the product. Can be empty or omitted if product is single-sku'),
+}).describe('A product is a wrapper around sellable items. It contains all the shared information for a set of SKUs. All products have at least one SKU, but can potentially have hundreds.');
+
 
-export type SKU = z.infer<typeof SKUSchema>;
-export type Product = z.infer<typeof ProductSchema>;
-export type ProductAttribute = z.infer<typeof ProductAttributeSchema>;
+export type ProductVariant = InferType<typeof ProductVariantSchema>;
+export type Product = InferType<typeof ProductSchema>;
+export type ProductAttribute = InferType<typeof ProductAttributeSchema>;
+export type ProductAttributeValue = InferType<typeof ProductAttributeValueSchema>;
+export type ProductOption = InferType<typeof ProductOptionSchema>;
+export type ProductOptionValue = InferType<typeof ProductOptionValueSchema>;
+export type ProductVariantOption = InferType<typeof ProductVariantOptionSchema>;

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

@@ -1,35 +1,32 @@
-import z from "zod";
+import { z } from "zod";
 import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model.js";
 import { BaseModelSchema } from "./base.model.js";
+import type { InferType } from '../../zod-utils.js';
 
 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'),
+    firstName: z.string(),
+    lastName: z.string(),
+    streetAddress: z.string(),
+    streetNumber: z.string(),
+    city: z.string(),
+    region: z.string(),
+    postalCode: z.string(),
+    countryCode: z.string(),
 });
 
 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()),
-
+    identifier: IdentityIdentifierSchema,
+    email: z.email(),
+    phone: z.string(),
+    emailVerified: z.boolean(),
+    phoneVerified: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
     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>;
+export type Address = InferType<typeof AddressSchema>;
+export type Profile = InferType<typeof ProfileSchema>;

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

@@ -1,45 +1,40 @@
-import z from "zod";
+import { z } from "zod";
 import { ShippingMethodIdentifierSchema } from "./identifiers.model.js";
 import { MonetaryAmountSchema } from "./price.model.js";
 import { BaseModelSchema, ImageSchema } from "./base.model.js";
 import { AddressSchema } from "./profile.model.js";
-
-
-
+import type { InferType } from '../../zod-utils.js';
 
 export const PickupPointSchema = z.looseObject({
     identifier: z.object({
-        key: z.string().default('').nonoptional()
-    }).default(() => ({ key: '' })),
-    name: z.string().default(''),
-    description: z.string().default(''),
-    address: AddressSchema.default(() => AddressSchema.parse({})),
-    openingHours: z.string().default('').optional().describe('The opening hours of the pickup point, if applicable. This could be a string like "Mon-Fri 9am-5pm".'),
-    contactPhone: z.string().default('').optional().describe('The contact phone number for the pickup point, if applicable.'),
-    contactEmail: z.string().default('').optional().describe('The contact email for the pickup point, if applicable.'),
-    instructions: z.string().default('').optional().describe('Any special instructions for picking up from this point.'),
+        key: z.string()
+    }),
+    name: z.string(),
+    description: z.string(),
+    address: AddressSchema,
+    openingHours: z.string().optional().describe('The opening hours of the pickup point, if applicable. This could be a string like "Mon-Fri 9am-5pm".'),
+    contactPhone: z.string().optional().describe('The contact phone number for the pickup point, if applicable.'),
+    contactEmail: z.string().optional().describe('The contact email for the pickup point, if applicable.'),
+    instructions: z.string().optional().describe('Any special instructions for picking up from this point.'),
 });
 
-
 export const ShippingMethodSchema = z.looseObject({
-    identifier: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
-    name: z.string().default(''),
-    description: z.string().default(''),
+    identifier: ShippingMethodIdentifierSchema,
+    name: z.string(),
+    description: z.string(),
     logo: ImageSchema.optional(),
-    price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
-    deliveryTime: z.string().default(''),
-    carrier: z.string().default('').optional(),
+    price: MonetaryAmountSchema,
+    deliveryTime: z.string(),
+    carrier: z.string().optional(),
 });
 
-
 export const ShippingInstructionSchema = BaseModelSchema.extend({
-    shippingMethod: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
-    pickupPoint: z.string().default('').describe('An optional pickup point for the shipping method. This could be a physical store, a locker, or similar. If not set, it means home delivery to the shipping address.'),
-    instructions: z.string().default('').describe('Optional instructions for the shipping. This could be delivery instructions, or similar.'),
-    consentForUnattendedDelivery: z.boolean().default(false).describe('Indicates if the customer has given consent for unattended delivery, if applicable.'),
+    shippingMethod: ShippingMethodIdentifierSchema,
+    pickupPoint: z.string().describe('An optional pickup point for the shipping method. This could be a physical store, a locker, or similar. If not set, it means home delivery to the shipping address.'),
+    instructions: z.string().describe('Optional instructions for the shipping. This could be delivery instructions, or similar.'),
+    consentForUnattendedDelivery: z.boolean().describe('Indicates if the customer has given consent for unattended delivery, if applicable.'),
 });
 
-
-export type ShippingMethod = z.infer<typeof ShippingMethodSchema>;
-export type PickupPoint = z.infer<typeof PickupPointSchema>;
-export type ShippingInstruction = z.infer<typeof ShippingInstructionSchema>;
+export type ShippingMethod = InferType<typeof ShippingMethodSchema>;
+export type PickupPoint = InferType<typeof PickupPointSchema>;
+export type ShippingInstruction = InferType<typeof ShippingInstructionSchema>;

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

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

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

@@ -1,22 +1,23 @@
 import { z } from 'zod';
 import { BaseMutationSchema } from './base.mutation.js';
-import { ProductIdentifierSchema, SearchIdentifierSchema } from '../models/identifiers.model.js';
+import { ProductIdentifierSchema, ProductSearchIdentifierSchema } from '../models/identifiers.model.js';
+import type { InferType } from '../../zod-utils.js';
 
 export const AnalyticsMutationSearchEventSchema = BaseMutationSchema.extend({
     mutation: z.literal('search'),
-    search: SearchIdentifierSchema.required(),
+    search: ProductSearchIdentifierSchema,
     products: z.array(ProductIdentifierSchema),
 });
 
 export const AnalyticsMutationSearchProductClickEventSchema = BaseMutationSchema.extend({
     mutation: z.literal('product-search-click'),
-    search: SearchIdentifierSchema.required(),
-    product: ProductIdentifierSchema.required(),
+    search: ProductSearchIdentifierSchema,
+    product: ProductIdentifierSchema,
     position: z.number().min(0)
 });
 
 export const AnalyticsMutationSchema = z.union([AnalyticsMutationSearchEventSchema, AnalyticsMutationSearchProductClickEventSchema]);
 
-export type AnalyticsMutation = z.infer<typeof AnalyticsMutationSchema>;
-export type AnalyticsMutationSearchEvent = z.infer<typeof AnalyticsMutationSearchEventSchema>;
-export type AnalyticsMutationSearchProductClickEvent = z.infer<typeof AnalyticsMutationSearchProductClickEventSchema>;
+export type AnalyticsMutation = InferType<typeof AnalyticsMutationSchema>;
+export type AnalyticsMutationSearchEvent = InferType<typeof AnalyticsMutationSearchEventSchema>;
+export type AnalyticsMutationSearchProductClickEvent = InferType<typeof AnalyticsMutationSearchProductClickEventSchema>;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
+import type { InferType } from '../../zod-utils.js';
 
 export const BaseMutationSchema = z.looseObject({
 });
 
-export type BaseMutation = z.infer<typeof BaseMutationSchema>;
+export type BaseMutation = InferType<typeof BaseMutationSchema>;

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

@@ -1,83 +1,83 @@
 import { z } from 'zod';
 import { BaseMutationSchema } from './base.mutation.js';
-import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifierSchema, SKUIdentifierSchema } from '../models/identifiers.model.js';
+import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifierSchema, ProductVariantIdentifierSchema } from '../models/identifiers.model.js';
 import { AddressSchema } from '../models/profile.model.js';
 import { CurrencySchema } from '../models/currency.model.js';
 import { MonetaryAmountSchema } from '../models/price.model.js';
+import type { InferType } from '../../zod-utils.js';
 
 export const CartMutationItemAddSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.nonoptional(),
-    sku: SKUIdentifierSchema.nonoptional(),
+    cart: CartIdentifierSchema.optional(),
+    variant: ProductVariantIdentifierSchema,
     quantity: z.number()
 });
 
 export const CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.nonoptional(),
-    item: CartItemIdentifierSchema.nonoptional()
+    cart: CartIdentifierSchema,
+    item: CartItemIdentifierSchema,
 });
 
 export const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.nonoptional(),
-    item: CartItemIdentifierSchema.nonoptional(),
+    cart: CartIdentifierSchema,
+    item: CartItemIdentifierSchema,
     quantity: z.number()
 });
 
 export const CartMutationDeleteCartSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required()
+    cart: CartIdentifierSchema
 });
 
 export const CartMutationSetShippingInfoSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required(),
+    cart: CartIdentifierSchema,
     shippingMethod: ShippingMethodIdentifierSchema.optional(),
     shippingAddress: AddressSchema.optional(),
 });
 
 export const CartMutationSetBillingAddressSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required(),
-    billingAddress: AddressSchema.required(),
+    cart: CartIdentifierSchema,
+    billingAddress: AddressSchema,
     notificationEmailAddress: z.string().optional(),
     notificationPhoneNumber: z.string().optional(),
 });
 
 export const CartMutationApplyCouponSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required(),
-    couponCode: z.string().default('').nonoptional()
+    cart: CartIdentifierSchema,
+    couponCode: z.string()
 });
 
 export const CartMutationRemoveCouponSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required(),
-    couponCode: z.string().default('').nonoptional()
+    cart: CartIdentifierSchema,
+    couponCode: z.string()
 });
 
 export const CartMutationCheckoutSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required()
+    cart: CartIdentifierSchema
 });
 
 export const CartMutationAddPaymentMethodSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required(),
-    paymentMethodId: PaymentMethodIdentifierSchema.required(),
+    cart: CartIdentifierSchema,
+    paymentMethodId: PaymentMethodIdentifierSchema,
     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(),
+    cart: CartIdentifierSchema,
 });
 
 export const CartMutationChangeCurrencySchema = BaseMutationSchema.extend({
     cart: CartIdentifierSchema.required(),
-    newCurrency: CurrencySchema.default(() => CurrencySchema.parse({})).describe('The new currency to set for the cart.')
+    newCurrency: CurrencySchema.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 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>;
+export type CartMutationChangeCurrency = InferType<typeof CartMutationChangeCurrencySchema>;
+export type CartMutationAddPaymentMethod = InferType<typeof CartMutationAddPaymentMethodSchema>;
+export type CartMutationRemovePaymentMethod = InferType<typeof CartMutationRemovePaymentMethodSchema>;
+export type CartMutationCheckout = InferType<typeof CartMutationCheckoutSchema>;
+export type CartMutationItemAdd = InferType<typeof CartMutationItemAddSchema>;
+export type CartMutationItemRemove = InferType<typeof CartMutationItemRemoveSchema>;
+export type CartMutationItemQuantityChange = InferType<typeof CartMutationItemQuantityChangeSchema>;
+export type CartMutationDeleteCart = InferType<typeof CartMutationDeleteCartSchema>;
+export type CartMutationSetShippingInfo = InferType<typeof CartMutationSetShippingInfoSchema>;
+export type CartMutationSetBillingAddress = InferType<typeof CartMutationSetBillingAddressSchema>;
+export type CartMutationApplyCoupon = InferType<typeof CartMutationApplyCouponSchema>;
+export type CartMutationRemoveCoupon = InferType<typeof CartMutationRemoveCouponSchema>;

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

@@ -1,50 +1,43 @@
-import  z from "zod";
-import { CartIdentifierSchema, AddressSchema, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, ShippingInstructionSchema } from "../models/index.js";
+import { z } from "zod";
+import { CartIdentifierSchema, AddressSchema, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, ShippingInstructionSchema, CartSchema } from "../models/index.js";
 import { BaseMutationSchema } from "./base.mutation.js";
+import type { InferType } from '../../zod-utils.js';
 
 
 export const CheckoutMutationInitiateCheckoutSchema = BaseMutationSchema.extend({
-    cart: CartIdentifierSchema.required(),
-    billingAddress: AddressSchema.omit({identifier: true}).optional(),
+    cart: CartSchema,
+    billingAddress: AddressSchema.omit({ identifier: true }).optional(),
     notificationEmail: z.string().optional(),
     notificationPhone: z.string().optional(),
 });
 
 export const CheckoutMutationSetShippingAddressSchema = BaseMutationSchema.extend({
-    checkout: CartIdentifierSchema.required(),
-    shippingAddress: AddressSchema.omit({identifier: true}).required(),
+    checkout: CartIdentifierSchema,
+    shippingAddress: AddressSchema.omit({ identifier: true }),
 });
 
-
 export const CheckoutMutationFinalizeCheckoutSchema = BaseMutationSchema.extend({
-    checkout: CartIdentifierSchema.required(),
+    checkout: CartIdentifierSchema,
 });
 
-
-export const CheckoutMutationAddPaymentInstruction = BaseMutationSchema.extend({
-    paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
-    checkout: CartIdentifierSchema.required()
+export const CheckoutMutationAddPaymentInstructionSchema = BaseMutationSchema.extend({
+    paymentInstruction: PaymentInstructionSchema.omit({ status: true, identifier: true }),
+    checkout: CartIdentifierSchema,
 });
 
-export const CheckoutMutationRemovePaymentInstruction = BaseMutationSchema.extend({
-    paymentInstruction: PaymentInstructionIdentifierSchema.required(),
-    checkout: CartIdentifierSchema.required()
+export const CheckoutMutationRemovePaymentInstructionSchema = BaseMutationSchema.extend({
+    paymentInstruction: PaymentInstructionIdentifierSchema,
+    checkout: CartIdentifierSchema,
 });
 
-
-
-export const CheckoutMutationSetShippingInstruction = BaseMutationSchema.extend({
-    shippingInstruction: ShippingInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
-    checkout: CartIdentifierSchema.required()
+export const CheckoutMutationSetShippingInstructionSchema = BaseMutationSchema.extend({
+    shippingInstruction: ShippingInstructionSchema,
+    checkout: CartIdentifierSchema,
 });
 
-
-
-
-
-export type CheckoutMutationInitiateCheckout = z.infer<typeof CheckoutMutationInitiateCheckoutSchema>;
-export type CheckoutMutationSetShippingAddress = z.infer<typeof CheckoutMutationSetShippingAddressSchema>;
-export type CheckoutMutationFinalizeCheckout = z.infer<typeof CheckoutMutationFinalizeCheckoutSchema>;
-export type CheckoutMutationAddPaymentInstruction = z.infer<typeof CheckoutMutationAddPaymentInstruction>;
-export type CheckoutMutationRemovePaymentInstruction = z.infer<typeof CheckoutMutationRemovePaymentInstruction>;
-export type CheckoutMutationSetShippingInstruction = z.infer<typeof CheckoutMutationSetShippingInstruction>;
+export type CheckoutMutationInitiateCheckout = InferType<typeof CheckoutMutationInitiateCheckoutSchema>;
+export type CheckoutMutationSetShippingAddress = InferType<typeof CheckoutMutationSetShippingAddressSchema>;
+export type CheckoutMutationFinalizeCheckout = InferType<typeof CheckoutMutationFinalizeCheckoutSchema>;
+export type CheckoutMutationAddPaymentInstruction = InferType<typeof CheckoutMutationAddPaymentInstructionSchema>;
+export type CheckoutMutationRemovePaymentInstruction = InferType<typeof CheckoutMutationRemovePaymentInstructionSchema>;
+export type CheckoutMutationSetShippingInstruction = InferType<typeof CheckoutMutationSetShippingInstructionSchema>;

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { BaseMutationSchema } from './base.mutation.js';
+import type { InferType } from '../../zod-utils.js';
 
 export const IdentityMutationLoginSchema = BaseMutationSchema.extend({
     username: z.string(),
@@ -15,6 +16,6 @@ export const IdentityMutationRegisterSchema = BaseMutationSchema.extend({
 });
 
 
-export type IdentityMutationLogin = z.infer<typeof IdentityMutationLoginSchema>;
-export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;
-export type IdentityMutationRegister = z.infer<typeof IdentityMutationRegisterSchema>;
+export type IdentityMutationLogin = InferType<typeof IdentityMutationLoginSchema>;
+export type IdentityMutationLogout = InferType<typeof IdentityMutationLogoutSchema>;
+export type IdentityMutationRegister = InferType<typeof IdentityMutationRegisterSchema>;

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

@@ -1,9 +1,44 @@
 import { z } from 'zod';
 import { BaseMutationSchema } from './base.mutation.js';
+import type { InferType } from '../../zod-utils.js';
+import { AddressIdentifierSchema, IdentityIdentifierSchema } from '../models/identifiers.model.js';
+import { AddressSchema } from '../models/profile.model.js';
 
 export const ProfileMutationUpdateSchema = BaseMutationSchema.extend({
-    email: z.email().default('base@example.com'),
-    phone: z.string().default(''),
+    identifier: IdentityIdentifierSchema,
+    email: z.email().describe('The main contact email of the profile'),
+    phone: z.string().describe('The main phone number of the profile'),
 });
 
-export type ProfileMutationUpdate = z.infer<typeof ProfileMutationUpdateSchema>;
+export const ProfileMutationAddShippingAddressSchema = BaseMutationSchema.extend({
+    identifier: IdentityIdentifierSchema,
+    address: AddressSchema,
+});
+
+export const ProfileMutationRemoveShippingAddressSchema = BaseMutationSchema.extend({
+    identifier: IdentityIdentifierSchema,
+    addressIdentifier: AddressIdentifierSchema,
+});
+
+export const ProfileMutationUpdateShippingAddressSchema = BaseMutationSchema.extend({
+    identifier: IdentityIdentifierSchema,
+    address: AddressSchema,
+});
+
+export const ProfileMutationMakeShippingAddressDefaultSchema = BaseMutationSchema.extend({
+    identifier: IdentityIdentifierSchema,
+    addressIdentifier: AddressIdentifierSchema,
+});
+
+export const ProfileMutationSetBillingAddressSchema = BaseMutationSchema.extend({
+    identifier: IdentityIdentifierSchema,
+    address: AddressSchema,
+});
+
+
+export type ProfileMutationUpdate = InferType<typeof ProfileMutationUpdateSchema>;
+export type ProfileMutationAddShippingAddress = InferType<typeof ProfileMutationAddShippingAddressSchema>;
+export type ProfileMutationRemoveShippingAddress = InferType<typeof ProfileMutationRemoveShippingAddressSchema>;
+export type ProfileMutationMakeShippingAddressDefault = InferType<typeof ProfileMutationMakeShippingAddressDefaultSchema>;
+export type ProfileMutationSetBillingAddress = InferType<typeof ProfileMutationSetBillingAddressSchema>;
+export type ProfileMutationUpdateShippingAddress = InferType<typeof ProfileMutationUpdateShippingAddressSchema>;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
+import type { InferType } from '../../zod-utils.js';
 
 export const BaseQuerySchema = z.looseObject({
 });
 
-export type BaseQuery = z.infer<typeof BaseQuerySchema>;
+export type BaseQuery = InferType<typeof BaseQuerySchema>;

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

@@ -1,9 +1,9 @@
-import type { z } from 'zod';
 import { BaseQuerySchema } from './base.query.js';
 import { CartIdentifierSchema } from '../models/identifiers.model.js';
+import type { InferType } from '../../zod-utils.js';
 
 export const CartQueryByIdSchema = BaseQuerySchema.extend({
-    cart: CartIdentifierSchema.required()
+    cart: CartIdentifierSchema
 });
 
-export type CartQueryById = z.infer<typeof CartQueryByIdSchema>;
+export type CartQueryById = InferType<typeof CartQueryByIdSchema>;

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

@@ -1,32 +1,32 @@
-import z from "zod";
+import { z } from "zod";
 import { CategoryIdentifierSchema } from "../models/identifiers.model.js";
 import { BaseQuerySchema } from "./base.query.js";
 import { PaginationOptionsSchema } from "../models/base.model.js";
+import type { InferType } from '../../zod-utils.js';
 
-export const CategoryQueryById = BaseQuerySchema.extend({
-    id: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
+export const CategoryQueryByIdSchema = BaseQuerySchema.extend({
+    id: CategoryIdentifierSchema,
 });
 
-export const CategoryQueryBySlug = BaseQuerySchema.extend({
-    slug: z.string().default(''),
+export const CategoryQueryBySlugSchema = BaseQuerySchema.extend({
+    slug: z.string(),
 });
 
-export const CategoryQueryForBreadcrumb = BaseQuerySchema.extend({
-    id: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
+export const CategoryQueryForBreadcrumbSchema = BaseQuerySchema.extend({
+    id: CategoryIdentifierSchema,
 });
 
-export const CategoryQueryForChildCategories = BaseQuerySchema.extend({
-    parentId: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
-    paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({})),
+export const CategoryQueryForChildCategoriesSchema = BaseQuerySchema.extend({
+    parentId: CategoryIdentifierSchema,
+    paginationOptions: PaginationOptionsSchema,
 });
 
-export const CategoryQueryForTopCategories = BaseQuerySchema.extend({
-    paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({})),
+export const CategoryQueryForTopCategoriesSchema = BaseQuerySchema.extend({
+    paginationOptions: PaginationOptionsSchema,
 });
 
-
-export type CategoryQueryById = z.infer<typeof CategoryQueryById>;
-export type CategoryQueryBySlug = z.infer<typeof CategoryQueryBySlug>;
-export type CategoryQueryForBreadcrumb = z.infer<typeof CategoryQueryForBreadcrumb>;
-export type CategoryQueryForChildCategories = z.infer<typeof CategoryQueryForChildCategories>;
-export type CategoryQueryForTopCategories = z.infer<typeof CategoryQueryForTopCategories>;
+export type CategoryQueryById = InferType<typeof CategoryQueryByIdSchema>;
+export type CategoryQueryBySlug = InferType<typeof CategoryQueryBySlugSchema>;
+export type CategoryQueryForBreadcrumb = InferType<typeof CategoryQueryForBreadcrumbSchema>;
+export type CategoryQueryForChildCategories = InferType<typeof CategoryQueryForChildCategoriesSchema>;
+export type CategoryQueryForTopCategories = InferType<typeof CategoryQueryForTopCategoriesSchema>;