@reactionary/core 0.0.80 → 0.0.82

package/decorators/reactionary.decorator.js

@@ -47,7 +47,7 @@ function Reactionary(options) {
       return traceSpan(scope, async () => {
         const input = validateInput(args[0], configuration.inputSchema);
         const cacheKey = this.generateCacheKeyForQuery(scope, input);
-        const fromCache = await this.cache.get(cacheKey, this.schema);
+        const fromCache = await this.cache.get(cacheKey, options.inputSchema);
         let result = fromCache;
         if (!result) {
           result = await original.apply(this, [input]);
@@ -81,7 +81,7 @@ async function traceSpan(name, fn) {
   const tracer = getTracer();
   return tracer.startActiveSpan(name, async (span) => {
     try {
-      return fn();
+      return await fn();
     } catch (err) {
       if (err instanceof Error) {
         span.recordException(err);

package/initialization.js

@@ -1,22 +1,5 @@
 function createInitialRequestContext() {
   return {
-    id: "",
-    identity: {
-      type: "Anonymous",
-      meta: {
-        cache: { hit: false, key: "" },
-        placeholder: false
-      },
-      id: { userId: "anonymous-" + crypto.randomUUID().toString() },
-      token: void 0,
-      issued: /* @__PURE__ */ new Date(),
-      expiry: new Date((/* @__PURE__ */ new Date()).getTime() + 3600 * 1e3),
-      logonId: "",
-      createdAt: "",
-      updatedAt: "",
-      keyring: [],
-      currentService: void 0
-    },
     languageContext: {
       locale: "en",
       currencyCode: "USD"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {

package/providers/base.provider.js

@@ -1,38 +1,10 @@
-import {
-  createPaginatedResponseSchema
-} from "../schemas/models/base.model.js";
 import {} from "../schemas/session.schema.js";
 import { hasher } from "node-object-hash";
 class BaseProvider {
-  constructor(schema, cache, context) {
-    this.schema = schema;
+  constructor(cache, context) {
     this.cache = cache;
     this.context = context;
   }
-  /**
-   * Validates that the final domain model constructed by the provider
-   * fulfills the schema as defined. This will throw an exception.
-   */
-  assert(value) {
-    return this.schema.parse(value);
-  }
-  /**
-   * Creates a new model entity based on the schema defaults.
-   */
-  newModel() {
-    return this.schema.parse({});
-  }
-  /**
-   * Handler for parsing a response from a remote provider and converting it
-   * into the typed domain model.
-   */
-  parseSingle(_body) {
-    const model = this.newModel();
-    return this.assert(model);
-  }
-  parsePaginatedResult(_body) {
-    return createPaginatedResponseSchema(this.schema).parse({});
-  }
   generateDependencyIdsForModel(model) {
     const identifier = model?.identifier;
     if (!identifier) {

package/providers/cart.provider.js

@@ -1,9 +1,42 @@
 import { BaseProvider } from "./base.provider.js";
 class CartProvider extends BaseProvider {
   createEmptyCart() {
-    const cart = this.newModel();
-    cart.meta = { placeholder: true, cache: { hit: true, key: "empty-cart" } };
-    cart.identifier = { key: "" };
+    const cart = {
+      identifier: { key: "" },
+      meta: { placeholder: true, cache: { hit: true, key: "empty-cart" } },
+      description: "",
+      items: [],
+      name: "",
+      price: {
+        grandTotal: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalDiscount: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalProductPrice: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalShipping: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalSurcharge: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalTax: {
+          value: 0,
+          currency: "XXX"
+        }
+      },
+      userId: {
+        userId: ""
+      }
+    };
     return cart;
   }
   getResourceName() {

package/providers/inventory.provider.js

@@ -4,7 +4,7 @@ class InventoryProvider extends BaseProvider {
     return "inventory";
   }
   createEmptyInventory(key) {
-    return this.schema.parse({
+    const inventory = {
       identifier: key,
       quantity: 0,
       status: "outOfStock",
@@ -15,7 +15,8 @@ class InventoryProvider extends BaseProvider {
         },
         placeholder: true
       }
-    });
+    };
+    return inventory;
   }
 }
 export {

package/providers/order.provider.js

@@ -1,9 +1,45 @@
 import { BaseProvider } from "./base.provider.js";
 class OrderProvider extends BaseProvider {
   createEmptyOrder() {
-    const order = this.newModel();
-    order.meta = { placeholder: true, cache: { hit: true, key: "empty-order" } };
-    order.identifier = { key: "" };
+    const order = {
+      meta: { placeholder: true, cache: { hit: true, key: "empty-order" } },
+      identifier: {
+        key: ""
+      },
+      inventoryStatus: "NotAllocated",
+      items: [],
+      orderStatus: "AwaitingPayment",
+      paymentInstructions: [],
+      price: {
+        grandTotal: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalDiscount: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalProductPrice: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalShipping: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalSurcharge: {
+          value: 0,
+          currency: "XXX"
+        },
+        totalTax: {
+          value: 0,
+          currency: "XXX"
+        }
+      },
+      userId: {
+        userId: ""
+      }
+    };
     return order;
   }
   getResourceName() {

package/providers/price.provider.js

@@ -9,19 +9,26 @@ class PriceProvider extends BaseProvider {
    * @returns
    */
   createEmptyPriceResult(sku) {
-    const base = this.newModel();
-    base.identifier = {
-      variant: { sku }
+    const price = {
+      identifier: {
+        variant: {
+          sku
+        }
+      },
+      tieredPrices: [],
+      unitPrice: {
+        value: -1,
+        currency: this.context.languageContext.currencyCode
+      },
+      meta: {
+        cache: {
+          hit: false,
+          key: `price-${sku}-${this.context.languageContext.currencyCode}`
+        },
+        placeholder: true
+      }
     };
-    base.unitPrice = {
-      value: -1,
-      currency: this.context.languageContext.currencyCode
-    };
-    base.meta = {
-      cache: { hit: false, key: `price-${sku}-${this.context.languageContext.currencyCode}` },
-      placeholder: true
-    };
-    return this.assert(base);
+    return price;
   }
   getResourceName() {
     return "price";

package/providers/product.provider.js

@@ -1,17 +1,40 @@
 import { BaseProvider } from "./base.provider.js";
 class ProductProvider extends BaseProvider {
-  /**
-   * Returns a set of Products for each variant. Is a paged response, to ensure we do not build in overfetching from the start.
-   *
-   * Usecase: You are rendering a variant-list on a b2b PDP page maybe, and it contains 500 variants. You do not want to fetch all 500 variants in one go.
-   * @param payload
-   * @param reqCtx
-   */
-  //  public abstract getVariantList(payload: ProductQueryVariants, reqCtx: RequestContext): Promise<typeof this.parsePaginatedResult>;
   createEmptyProduct(id) {
-    const product = this.newModel();
-    product.identifier = { key: id };
-    product.meta.placeholder = true;
+    const product = {
+      brand: "",
+      description: "",
+      identifier: {
+        key: id
+      },
+      longDescription: "",
+      mainVariant: {
+        barcode: "",
+        ean: "",
+        gtin: "",
+        identifier: {
+          sku: ""
+        },
+        images: [],
+        name: "",
+        options: [],
+        upc: ""
+      },
+      manufacturer: "",
+      meta: {
+        cache: {
+          hit: false,
+          key: ""
+        },
+        placeholder: false
+      },
+      name: "",
+      options: [],
+      parentCategories: [],
+      published: false,
+      sharedAttributes: [],
+      slug: ""
+    };
     return product;
   }
   /**

package/schemas/models/identifiers.model.js

@@ -1,95 +1,93 @@
 import { z } from "zod";
 import { PaginationOptionsSchema } from "./base.model.js";
 const FacetIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const FacetValueIdentifierSchema = z.object({
-  facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
-  key: z.string().default("")
+  facet: FacetIdentifierSchema,
+  key: z.string()
 });
 const ProductVariantIdentifierSchema = z.looseObject({
-  sku: z.string().default("").nonoptional()
+  sku: z.string()
 });
 const ProductAttributeIdentifierSchema = z.looseObject({
-  key: z.string().default("").describe("The unique identifier for the product attribute.")
+  key: z.string().describe("The unique identifier for the product attribute.")
 });
 const ProductAttributeValueIdentifierSchema = z.looseObject({
-  key: z.string().default("").describe("The unique identifier for the product attribute value.")
+  key: z.string().describe("The unique identifier for the product attribute value.")
 });
 const ProductOptionIdentifierSchema = z.looseObject({
-  key: z.string().default("").describe("The unique identifier for the product option.")
+  key: z.string().describe("The unique identifier for the product option.")
 });
 const ProductOptionValueIdentifierSchema = z.looseObject({
-  option: ProductOptionIdentifierSchema.default(() => ProductOptionIdentifierSchema.parse({})),
-  key: z.string().default("").describe('The value of the product option, e.g., "Red" or "Large".')
+  option: ProductOptionIdentifierSchema,
+  key: z.string().describe('The value of the product option, e.g., "Red" or "Large".')
 });
 const ProductIdentifierSchema = z.looseObject({
-  key: z.string().default("")
+  key: z.string()
 });
 const ProductSearchIdentifierSchema = z.looseObject({
-  term: z.string().default(""),
-  facets: z.array(FacetValueIdentifierSchema.required()).default(() => []),
-  filters: z.array(z.string()).default(() => []),
-  paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({}))
+  term: z.string(),
+  facets: z.array(FacetValueIdentifierSchema),
+  filters: z.array(z.string()),
+  paginationOptions: PaginationOptionsSchema
 });
 const CartIdentifierSchema = z.looseObject({
-  key: z.string().default("")
+  key: z.string()
 });
 const CartItemIdentifierSchema = z.looseObject({
-  key: z.string().default("")
+  key: z.string()
 });
 const PriceIdentifierSchema = z.looseObject({
-  variant: ProductVariantIdentifierSchema.default(() => ProductVariantIdentifierSchema.parse({}))
+  variant: ProductVariantIdentifierSchema
 });
 const CategoryIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const StoreIdentifierSchema = z.looseObject({
-  key: z.string().default("").optional()
+  key: z.string()
 });
 const OrderIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const OrderItemIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const CheckoutIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const CheckoutItemIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const WebStoreIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const FulfillmentCenterIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const InventoryIdentifierSchema = z.looseObject({
-  variant: ProductVariantIdentifierSchema.default(() => ProductVariantIdentifierSchema.parse({})),
-  fulfillmentCenter: FulfillmentCenterIdentifierSchema.default(
-    () => FulfillmentCenterIdentifierSchema.parse({})
-  )
+  variant: ProductVariantIdentifierSchema,
+  fulfillmentCenter: FulfillmentCenterIdentifierSchema
 });
 const IdentityIdentifierSchema = z.looseObject({
-  userId: z.string().default("").nonoptional()
+  userId: z.string()
 });
 const ShippingMethodIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const PaymentMethodIdentifierSchema = z.looseObject({
-  method: z.string().default("").nonoptional(),
-  name: z.string().default("").nonoptional(),
-  paymentProcessor: z.string().default("").nonoptional()
+  method: z.string(),
+  name: z.string(),
+  paymentProcessor: z.string()
 });
 const AddressIdentifierSchema = z.looseObject({
-  nickName: z.string().default("").nonoptional()
+  nickName: z.string()
 });
 const PaymentInstructionIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 const PickupPointIdentifierSchema = z.looseObject({
-  key: z.string().default("").nonoptional()
+  key: z.string()
 });
 export {
   AddressIdentifierSchema,

package/schemas/models/identity.model.js

@@ -2,15 +2,15 @@ import { z } from "zod";
 import { BaseModelSchema } from "./base.model.js";
 import { IdentityIdentifierSchema } from "./identifiers.model.js";
 const AnonymousIdentitySchema = BaseModelSchema.extend({
-  type: z.literal("Anonymous").default("Anonymous")
+  type: z.literal("Anonymous")
 });
 const GuestIdentitySchema = BaseModelSchema.extend({
-  id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-  type: z.literal("Guest").default("Guest")
+  id: IdentityIdentifierSchema,
+  type: z.literal("Guest")
 });
 const RegisteredIdentitySchema = BaseModelSchema.extend({
-  id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-  type: z.literal("Registered").default("Registered")
+  id: IdentityIdentifierSchema,
+  type: z.literal("Registered")
 });
 const IdentitySchema = z.discriminatedUnion("type", [AnonymousIdentitySchema, GuestIdentitySchema, RegisteredIdentitySchema]);
 export {

package/schemas/models/inventory.model.js

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import { BaseModelSchema } from "./base.model.js";
-import { InventoryIdentifierSchema, ProductVariantIdentifierSchema } from "./identifiers.model.js";
+import { InventoryIdentifierSchema } from "./identifiers.model.js";
+const InventoryStatusSchema = z.enum(["inStock", "outOfStock", "onBackOrder", "preOrder", "discontinued"]);
 const InventorySchema = BaseModelSchema.extend({
-  identifier: InventoryIdentifierSchema.default(() => InventoryIdentifierSchema.parse({})),
-  quantity: z.number().default(0),
-  status: z.enum(["inStock", "outOfStock", "onBackOrder", "preOrder", "discontinued"]).default("inStock")
+  identifier: InventoryIdentifierSchema,
+  quantity: z.number(),
+  status: InventoryStatusSchema
 });
 export {
-  InventorySchema
+  InventorySchema,
+  InventoryStatusSchema
 };

package/schemas/models/order.model.js

@@ -5,28 +5,28 @@ import { AddressSchema } from "./profile.model.js";
 import { ShippingMethodSchema } from "./shipping-method.model.js";
 import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model.js";
 import { PaymentInstructionSchema } from "./payment.model.js";
-const OrderStatusSchema = z.enum(["AwaitingPayment", "ReleasedToFulfillment", "Shipped", "Cancelled"]).default("AwaitingPayment").describe("The current status of the order.");
-const OrderInventoryStatusSchema = z.enum(["NotAllocated", "Allocated", "Backordered", "Preordered"]).default("Allocated").describe("The inventory release status of the order.");
+const OrderStatusSchema = z.enum(["AwaitingPayment", "ReleasedToFulfillment", "Shipped", "Cancelled"]).describe("The current status of the order.");
+const OrderInventoryStatusSchema = z.enum(["NotAllocated", "Allocated", "Backordered", "Preordered"]).describe("The inventory release status of the order.");
 const OrderItemSchema = z.looseObject({
-  identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
-  variant: ProductVariantIdentifierSchema.default(() => ProductVariantIdentifierSchema.parse({})),
-  quantity: z.number().default(0),
-  price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({})),
-  inventoryStatus: OrderInventoryStatusSchema.default("Allocated").describe("The inventory release status of the order item.")
+  identifier: CartItemIdentifierSchema,
+  variant: ProductVariantIdentifierSchema,
+  quantity: z.number(),
+  price: ItemCostBreakdownSchema,
+  inventoryStatus: OrderInventoryStatusSchema.describe("The inventory release status of the order item.")
 });
 const OrderSchema = BaseModelSchema.extend({
-  identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
-  userId: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-  items: z.array(OrderItemSchema).default(() => []),
-  price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
-  name: z.string().default(""),
-  description: z.string().default(""),
+  identifier: CartIdentifierSchema,
+  userId: IdentityIdentifierSchema,
+  items: z.array(OrderItemSchema),
+  price: CostBreakDownSchema,
+  name: z.string().optional(),
+  description: z.string().optional(),
   shippingAddress: AddressSchema.optional(),
   billingAddress: AddressSchema.optional(),
   shippingMethod: ShippingMethodSchema.optional(),
-  orderStatus: OrderStatusSchema.default("AwaitingPayment"),
-  inventoryStatus: OrderInventoryStatusSchema.default("Allocated"),
-  paymentInstructions: z.array(PaymentInstructionSchema).default(() => []),
+  orderStatus: OrderStatusSchema,
+  inventoryStatus: OrderInventoryStatusSchema,
+  paymentInstructions: z.array(PaymentInstructionSchema),
   cartReference: CartIdentifierSchema.optional().describe("Reference to the cart from which this order was created.")
 });
 export {

package/schemas/models/payment.model.js

@@ -4,21 +4,21 @@ import { PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } fro
 import { MonetaryAmountSchema } from "./price.model.js";
 const PaymentStatusSchema = z.enum(["pending", "authorized", "canceled", "capture", "partial_capture", "refunded", "partial_refund"]);
 const PaymentProtocolDataSchema = z.looseObject({
-  key: z.string().default(""),
-  value: z.string().default("")
+  key: z.string(),
+  value: z.string()
 });
 const PaymentMethodSchema = BaseModelSchema.extend({
-  identifier: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+  identifier: PaymentMethodIdentifierSchema,
   logo: ImageSchema.optional(),
-  description: z.string().default(""),
-  isPunchOut: z.boolean().default(true)
+  description: z.string(),
+  isPunchOut: z.boolean()
 });
 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")
+  identifier: PaymentInstructionIdentifierSchema,
+  amount: MonetaryAmountSchema,
+  paymentMethod: PaymentMethodIdentifierSchema,
+  protocolData: z.array(PaymentProtocolDataSchema).describe("Additional protocol-specific data for processing the payment."),
+  status: PaymentStatusSchema
 });
 export {
   PaymentInstructionSchema,

package/schemas/models/price.model.js

@@ -3,17 +3,17 @@ import { BaseModelSchema } from "./base.model.js";
 import { PriceIdentifierSchema } from "./identifiers.model.js";
 import { CurrencySchema } from "./currency.model.js";
 const MonetaryAmountSchema = z.looseObject({
-  value: z.number().default(0).describe("The monetary amount in decimal-precision."),
-  currency: CurrencySchema.default("XXX").describe("The currency associated with the amount, as a ISO 4217 standardized code.")
+  value: z.number().describe("The monetary amount in decimal-precision."),
+  currency: CurrencySchema.describe("The currency associated with the amount, as a ISO 4217 standardized code.")
 });
 const TieredPriceSchema = z.looseObject({
-  minimumQuantity: z.number().default(0).describe("The minimum quantity required to be eligible for the tiered price."),
-  price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The monetary amount for the tiered price.")
+  minimumQuantity: z.number().describe("The minimum quantity required to be eligible for the tiered price."),
+  price: MonetaryAmountSchema.describe("The monetary amount for the tiered price.")
 });
 const PriceSchema = BaseModelSchema.extend({
-  identifier: PriceIdentifierSchema.default(() => PriceIdentifierSchema.parse({})),
-  unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
-  tieredPrices: z.array(TieredPriceSchema).default(() => [])
+  identifier: PriceIdentifierSchema,
+  unitPrice: MonetaryAmountSchema,
+  tieredPrices: z.array(TieredPriceSchema)
 });
 export {
   MonetaryAmountSchema,

package/schemas/models/product-search.model.js

@@ -3,30 +3,30 @@ import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSch
 import { BaseModelSchema, createPaginatedResponseSchema, ImageSchema } from "./base.model.js";
 import { ProductVariantOptionSchema } from "./product.model.js";
 const ProductSearchResultItemVariantSchema = z.looseObject({
-  variant: ProductVariantIdentifierSchema.default(() => ProductVariantIdentifierSchema.parse({})).describe("The specific variant of the product"),
-  image: ImageSchema.default(() => ImageSchema.parse({})).describe("The image representing this variant in the search results"),
+  variant: ProductVariantIdentifierSchema.describe("The specific variant of the product"),
+  image: ImageSchema.describe("The image representing this variant in the search results"),
   options: ProductVariantOptionSchema.optional().describe("The subset of options that can reasonably be applied on a PLP")
 });
 const ProductSearchResultItemSchema = BaseModelSchema.extend({
-  identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
-  name: z.string().default(""),
-  slug: z.string().default(""),
-  variants: z.array(ProductSearchResultItemVariantSchema).default(() => []).describe("A list of variants associated with the product in the search results. If exactly one is present, you can use add-to-cart directly from PLP. If none are present, you must direct to PDP. If mulitple are present, and no options are set, you must direct to PDP. If multiple are present, and they have options, you can render swatches on PLP and allow customer to flip between variants.")
+  identifier: ProductIdentifierSchema,
+  name: z.string(),
+  slug: z.string(),
+  variants: z.array(ProductSearchResultItemVariantSchema).describe("A list of variants associated with the product in the search results. If exactly one is present, you can use add-to-cart directly from PLP. If none are present, you must direct to PDP. If mulitple are present, and no options are set, you must direct to PDP. If multiple are present, and they have options, you can render swatches on PLP and allow customer to flip between variants.")
 });
 const ProductSearchResultFacetValueSchema = z.looseObject({
-  identifier: FacetValueIdentifierSchema.default(() => FacetValueIdentifierSchema.parse({})),
-  name: z.string().default(""),
-  count: z.number().default(0),
-  active: z.boolean().default(false)
+  identifier: FacetValueIdentifierSchema,
+  name: z.string(),
+  count: z.number(),
+  active: z.boolean()
 });
 const ProductSearchResultFacetSchema = z.looseObject({
-  identifier: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
-  name: z.string().default(""),
-  values: z.array(ProductSearchResultFacetValueSchema).default(() => [])
+  identifier: FacetIdentifierSchema,
+  name: z.string(),
+  values: z.array(ProductSearchResultFacetValueSchema)
 });
 const ProductSearchResultSchema = createPaginatedResponseSchema(ProductSearchResultItemSchema).extend({
-  identifier: ProductSearchIdentifierSchema.default(() => ProductSearchIdentifierSchema.parse({})),
-  facets: z.array(ProductSearchResultFacetSchema).default(() => [])
+  identifier: ProductSearchIdentifierSchema,
+  facets: z.array(ProductSearchResultFacetSchema)
 });
 export {
   ProductSearchResultFacetSchema,