@reactionary/core 0.0.39 → 0.0.41

package/decorators/reactionary.decorator.js

@@ -0,0 +1,13 @@
+function Reactionary(options) {
+  return function(target, propertyKey, descriptor) {
+    const original = descriptor.value;
+    descriptor.value = function(...args) {
+      console.log("calling through reactionary decoration!");
+      return original.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+export {
+  Reactionary
+};

package/index.js

@@ -4,6 +4,7 @@ export * from "./cache/redis-cache";
 export * from "./cache/noop-cache";
 export * from "./client/client";
 export * from "./client/client-builder";
+export * from "./decorators/reactionary.decorator";
 export * from "./providers/analytics.provider";
 export * from "./providers/base.provider";
 export * from "./providers/cart.provider";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@reactionary/core",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "zod": "4.0.0-beta.20250430T185432",
+    "zod": "4.1.9",
     "@upstash/redis": "^1.34.9"
   }
 }

package/schemas/capabilities.schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-const CapabilitiesSchema = z.looseInterface({
+const CapabilitiesSchema = z.looseObject({
   product: z.boolean(),
   search: z.boolean(),
   analytics: z.boolean(),

package/schemas/models/base.model.js

@@ -1,16 +1,16 @@
 import { z } from "zod";
-const CacheInformationSchema = z.looseInterface({
+const CacheInformationSchema = z.looseObject({
   hit: z.boolean().default(false),
   key: z.string().default("")
 });
-const MetaSchema = z.looseInterface({
+const MetaSchema = z.looseObject({
   cache: CacheInformationSchema.default(() => CacheInformationSchema.parse({})),
   placeholder: z.boolean().default(false).describe("Whether or not the entity exists in a remote system, or is a default placeholder.")
 });
-const BaseModelSchema = z.looseInterface({
+const BaseModelSchema = z.looseObject({
   meta: MetaSchema.default(() => MetaSchema.parse({}))
 });
-const PaginationOptionsSchema = z.looseInterface({
+const PaginationOptionsSchema = z.looseObject({
   pageNumber: z.number().default(1).describe("Current page number, starting from 1"),
   pageSize: z.number().default(20).describe("Number of items per page")
 });
@@ -24,7 +24,7 @@ function createPaginatedResponseSchema(itemSchema) {
     items: z.array(itemSchema)
   });
 }
-const ImageSchema = z.looseInterface({
+const ImageSchema = z.looseObject({
   sourceUrl: z.string().default("").describe("The original source URL of the image. Pass this through your image resizing and transcoding service to get the desired size, and generate thumbnails as needed"),
   altText: z.string().default("").describe("Alternative text for the image, for accessibility purposes. Must always be set, and non-empty"),
   width: z.number().optional().describe("Width of the original image, in pixels, if known"),

package/schemas/models/cart.model.js

@@ -16,7 +16,7 @@ const ItemCostBreakdownSchema = z.looseObject({
   totalPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price for all units of the item."),
   totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total discount applied to all units of the item.")
 });
-const CartItemSchema = z.looseInterface({
+const CartItemSchema = z.looseObject({
   identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
   product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
   quantity: z.number().default(0),

package/schemas/models/identifiers.model.js

@@ -1,42 +1,42 @@
 import { z } from "zod";
-const FacetIdentifierSchema = z.looseInterface({
+const FacetIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
-const FacetValueIdentifierSchema = z.looseInterface({
+const FacetValueIdentifierSchema = z.looseObject({
   facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
   key: z.string().default("")
 });
-const SKUIdentifierSchema = z.looseInterface({
+const SKUIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
-const ProductIdentifierSchema = z.looseInterface({
+const ProductIdentifierSchema = z.looseObject({
   key: z.string().default("")
 });
-const SearchIdentifierSchema = z.looseInterface({
+const SearchIdentifierSchema = z.looseObject({
   term: z.string().default(""),
   page: z.number().default(0),
   pageSize: z.number().default(20),
   facets: z.array(FacetValueIdentifierSchema.required()).default(() => [])
 });
-const CartIdentifierSchema = z.looseInterface({
+const CartIdentifierSchema = z.looseObject({
   key: z.string().default("")
 });
-const CartItemIdentifierSchema = z.looseInterface({
+const CartItemIdentifierSchema = z.looseObject({
   key: z.string().default("")
 });
-const PriceIdentifierSchema = z.looseInterface({
+const PriceIdentifierSchema = z.looseObject({
   sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
 });
-const CategoryIdentifierSchema = z.looseInterface({
+const CategoryIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
-const WebStoreIdentifierSchema = z.looseInterface({
+const WebStoreIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
-const InventoryChannelIdentifierSchema = z.looseInterface({
+const InventoryChannelIdentifierSchema = z.looseObject({
   key: z.string().default("online").nonoptional()
 });
-const InventoryIdentifierSchema = z.looseInterface({
+const InventoryIdentifierSchema = z.looseObject({
   sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
   channelId: InventoryChannelIdentifierSchema.default(() => InventoryChannelIdentifierSchema.parse({}))
 });

package/schemas/models/price.model.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { BaseModelSchema } from "./base.model";
 import { PriceIdentifierSchema } from "./identifiers.model";
 import { CurrencySchema } from "./currency.model";
-const MonetaryAmountSchema = z.looseInterface({
+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.")
 });

package/schemas/models/product.model.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { ProductIdentifierSchema } from "./identifiers.model";
 import { BaseModelSchema } from "./base.model";
-const SKUSchema = z.looseInterface({
+const SKUSchema = z.looseObject({
   identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
 });
-const ProductAttributeSchema = z.looseInterface({
+const ProductAttributeSchema = z.looseObject({
   id: z.string(),
   name: z.string(),
   value: z.string()

package/schemas/models/search.model.js

@@ -1,19 +1,19 @@
 import { z } from "zod";
 import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSchema, SearchIdentifierSchema } from "./identifiers.model";
 import { BaseModelSchema } from "./base.model";
-const SearchResultProductSchema = z.looseInterface({
+const SearchResultProductSchema = z.looseObject({
   identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
   name: z.string().default(""),
   image: z.string().url().default("https://placehold.co/400"),
   slug: z.string().default("")
 });
-const SearchResultFacetValueSchema = z.looseInterface({
+const SearchResultFacetValueSchema = z.looseObject({
   identifier: FacetValueIdentifierSchema.default(() => FacetValueIdentifierSchema.parse({})),
   name: z.string().default(""),
   count: z.number().default(0),
   active: z.boolean().default(false)
 });
-const SearchResultFacetSchema = z.looseInterface({
+const SearchResultFacetSchema = z.looseObject({
   identifier: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
   name: z.string().default(""),
   values: z.array(SearchResultFacetValueSchema).default(() => [])

package/schemas/mutations/base.mutation.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-const BaseMutationSchema = z.looseInterface({});
+const BaseMutationSchema = z.looseObject({});
 export {
   BaseMutationSchema
 };

package/schemas/mutations/cart.mutation.js

@@ -2,17 +2,17 @@ import { z } from "zod";
 import { BaseMutationSchema } from "./base.mutation";
 import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from "../models/identifiers.model";
 const CartMutationItemAddSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  product: ProductIdentifierSchema.required(),
+  cart: CartIdentifierSchema.nonoptional(),
+  product: ProductIdentifierSchema.nonoptional(),
   quantity: z.number()
 });
 const CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  item: CartItemIdentifierSchema.required()
+  cart: CartIdentifierSchema.nonoptional(),
+  item: CartItemIdentifierSchema.nonoptional()
 });
 const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  item: CartItemIdentifierSchema.required(),
+  cart: CartIdentifierSchema.nonoptional(),
+  item: CartItemIdentifierSchema.nonoptional(),
   quantity: z.number()
 });
 export {

package/schemas/mutations/inventory.mutation.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-const InventoryMutationSchema = z.union([]);
-export {
-  InventoryMutationSchema
-};

package/schemas/mutations/price.mutation.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-const PriceMutationSchema = z.union([]);
-export {
-  PriceMutationSchema
-};

package/schemas/mutations/product.mutation.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-const ProductMutationSchema = z.union([]);
-export {
-  ProductMutationSchema
-};

package/schemas/mutations/search.mutation.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-const SearchMutationSchema = z.union([]);
-export {
-  SearchMutationSchema
-};

package/schemas/queries/analytics.query.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-const AnalyticsQuerySchema = z.union([]);
-export {
-  AnalyticsQuerySchema
-};

package/schemas/queries/base.query.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-const BaseQuerySchema = z.looseInterface({});
+const BaseQuerySchema = z.looseObject({});
 export {
   BaseQuerySchema
 };

package/schemas/queries/cart.query.js

@@ -1,11 +1,8 @@
-import { z } from "zod";
 import { BaseQuerySchema } from "./base.query";
 import { CartIdentifierSchema } from "../models/identifiers.model";
 const CartQueryByIdSchema = BaseQuerySchema.extend({
   cart: CartIdentifierSchema.required()
 });
-const CartQuerySchema = z.union([CartQueryByIdSchema]);
 export {
-  CartQueryByIdSchema,
-  CartQuerySchema
+  CartQueryByIdSchema
 };

package/schemas/queries/inventory.query.js

@@ -5,9 +5,7 @@ const InventoryQueryBySKUSchema = BaseQuerySchema.extend({
   query: z.literal("sku"),
   sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
 });
-const InventoryQuerySchema = z.union([InventoryQueryBySKUSchema]);
 ;
 export {
-  InventoryQueryBySKUSchema,
-  InventoryQuerySchema
+  InventoryQueryBySKUSchema
 };

package/src/decorators/reactionary.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Reactionary(options: unknown): MethodDecorator;

package/src/index.d.ts

@@ -4,6 +4,7 @@ export * from './cache/redis-cache';
 export * from './cache/noop-cache';
 export * from './client/client';
 export * from './client/client-builder';
+export * from './decorators/reactionary.decorator';
 export * from './providers/analytics.provider';
 export * from './providers/base.provider';
 export * from './providers/cart.provider';

package/src/schemas/capabilities.schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const CapabilitiesSchema: z.ZodInterface<{
+export declare const CapabilitiesSchema: z.ZodObject<{
     product: z.ZodBoolean;
     search: z.ZodBoolean;
     analytics: z.ZodBoolean;
@@ -8,9 +8,5 @@ export declare const CapabilitiesSchema: z.ZodInterface<{
     inventory: z.ZodBoolean;
     price: z.ZodBoolean;
     category: z.ZodBoolean;
-}, {
-    optional: never;
-    defaulted: never;
-    extra: Record<string, unknown>;
-}>;
+}, z.core.$loose>;
 export type Capabilities = z.infer<typeof CapabilitiesSchema>;

package/src/schemas/models/analytics.model.d.ts

@@ -1,27 +1,11 @@
 import { z } from 'zod';
-export declare const AnalyticsEventSchema: z.MergeInterfaces<z.ZodInterface<{
-    meta: z.ZodDefault<z.ZodInterface<{
-        cache: z.ZodDefault<z.ZodInterface<{
+export declare const AnalyticsEventSchema: z.ZodObject<{
+    meta: z.ZodDefault<z.ZodObject<{
+        cache: z.ZodDefault<z.ZodObject<{
             hit: z.ZodDefault<z.ZodBoolean>;
             key: z.ZodDefault<z.ZodString>;
-        }, {
-            optional: never;
-            defaulted: never;
-            extra: Record<string, unknown>;
-        }>>;
+        }, z.core.$loose>>;
         placeholder: z.ZodDefault<z.ZodBoolean>;
-    }, {
-        optional: never;
-        defaulted: never;
-        extra: Record<string, unknown>;
-    }>>;
-}, {
-    optional: never;
-    defaulted: never;
-    extra: Record<string, unknown>;
-}>, z.ZodInterface<{}, {
-    optional: never;
-    defaulted: never;
-    extra: {};
-}>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
 export type AnalyticsEvent = z.infer<typeof AnalyticsEventSchema>;

package/src/schemas/models/base.model.d.ts

@@ -1,99 +1,59 @@
 import { z } from 'zod';
-export declare const CacheInformationSchema: z.ZodInterface<{
+export declare const CacheInformationSchema: z.ZodObject<{
     hit: z.ZodDefault<z.ZodBoolean>;
     key: z.ZodDefault<z.ZodString>;
-}, {
-    optional: never;
-    defaulted: never;
-    extra: Record<string, unknown>;
-}>;
-export declare const MetaSchema: z.ZodInterface<{
-    cache: z.ZodDefault<z.ZodInterface<{
+}, z.core.$loose>;
+export declare const MetaSchema: z.ZodObject<{
+    cache: z.ZodDefault<z.ZodObject<{
         hit: z.ZodDefault<z.ZodBoolean>;
         key: z.ZodDefault<z.ZodString>;
-    }, {
-        optional: never;
-        defaulted: never;
-        extra: Record<string, unknown>;
-    }>>;
+    }, z.core.$loose>>;
     placeholder: z.ZodDefault<z.ZodBoolean>;
-}, {
-    optional: never;
-    defaulted: never;
-    extra: Record<string, unknown>;
-}>;
-export declare const BaseModelSchema: z.ZodInterface<{
-    meta: z.ZodDefault<z.ZodInterface<{
-        cache: z.ZodDefault<z.ZodInterface<{
+}, z.core.$loose>;
+export declare const BaseModelSchema: z.ZodObject<{
+    meta: z.ZodDefault<z.ZodObject<{
+        cache: z.ZodDefault<z.ZodObject<{
             hit: z.ZodDefault<z.ZodBoolean>;
             key: z.ZodDefault<z.ZodString>;
-        }, {
-            optional: never;
-            defaulted: never;
-            extra: Record<string, unknown>;
-        }>>;
+        }, z.core.$loose>>;
         placeholder: z.ZodDefault<z.ZodBoolean>;
-    }, {
-        optional: never;
-        defaulted: never;
-        extra: Record<string, unknown>;
-    }>>;
-}, {
-    optional: never;
-    defaulted: never;
-    extra: Record<string, unknown>;
-}>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
 export type CacheInformation = z.infer<typeof CacheInformationSchema>;
 export type Meta = z.infer<typeof MetaSchema>;
 export type BaseModel = z.infer<typeof BaseModelSchema>;
-export declare const PaginationOptionsSchema: z.ZodInterface<{
+export declare const PaginationOptionsSchema: z.ZodObject<{
     pageNumber: z.ZodDefault<z.ZodNumber>;
     pageSize: z.ZodDefault<z.ZodNumber>;
-}, {
-    optional: never;
-    defaulted: never;
-    extra: Record<string, unknown>;
-}>;
+}, z.core.$loose>;
 export type PaginationOptions = z.infer<typeof PaginationOptionsSchema>;
 /**
  * This seemed like the right way to do it, but we need to be able to pass in the item schema even later than this
  *
  **/
 export declare function createPaginatedResponseSchema<ItemType extends z.ZodTypeAny>(itemSchema: ItemType): z.ZodObject<{
-    meta: z.ZodDefault<z.ZodInterface<{
-        cache: z.ZodDefault<z.ZodInterface<{
+    meta: z.ZodDefault<z.ZodObject<{
+        cache: z.ZodDefault<z.ZodObject<{
             hit: z.ZodDefault<z.ZodBoolean>;
             key: z.ZodDefault<z.ZodString>;
-        }, {
-            optional: never;
-            defaulted: never;
-            extra: Record<string, unknown>;
-        }>>;
+        }, z.core.$loose>>;
         placeholder: z.ZodDefault<z.ZodBoolean>;
-    }, {
-        optional: never;
-        defaulted: never;
-        extra: Record<string, unknown>;
-    }>>;
+    }, z.core.$loose>>;
     pageNumber: z.ZodNumber;
     pageSize: z.ZodNumber;
     totalCount: z.ZodNumber;
     totalPages: z.ZodNumber;
     items: z.ZodArray<ItemType>;
-}, {}>;
+}, z.core.$strip>;
 /**
  * I posit, we should not have final urls in this, but rather assume the frontend has some kind of image transcoding/resizing service it will use to pass the image through, so
  * what we really need is the original source url, and then some metadata about the image.
  * Ie, rather than having distinct thumbnail and image fields, we just have a list of images, and the frontend will generate its own thumbnails as needed?
  */
-export declare const ImageSchema: z.ZodInterface<{
+export declare const ImageSchema: z.ZodObject<{
     sourceUrl: z.ZodDefault<z.ZodString>;
     altText: z.ZodDefault<z.ZodString>;
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
-}, {
-    optional: never;
-    defaulted: never;
-    extra: Record<string, unknown>;
-}>;
+}, z.core.$loose>;
 export type Image = z.infer<typeof ImageSchema>;