@reactionary/core 0.0.41 → 0.0.48

package/cache/memory-cache.js

@@ -0,0 +1,39 @@
+class MemoryCache {
+  constructor() {
+    this.entries = new Array();
+  }
+  async get(key, schema) {
+    const c = this.entries.find((x) => x.key === key);
+    if (!c) {
+      return null;
+    }
+    const parsed = schema.parse(c.value);
+    parsed.meta.cache.hit = true;
+    return parsed;
+  }
+  async put(key, value, options) {
+    this.entries.push({
+      key,
+      value,
+      options
+    });
+    return;
+  }
+  async invalidate(dependencyIds) {
+    let index = 0;
+    for (const entry of this.entries) {
+      for (const entryDependency of entry.options.dependencyIds) {
+        if (dependencyIds.indexOf(entryDependency) > -1) {
+          this.entries.splice(index, 1);
+        }
+      }
+      index++;
+    }
+  }
+  async clear() {
+    this.entries = [];
+  }
+}
+export {
+  MemoryCache
+};

package/cache/noop-cache.js

@@ -2,25 +2,15 @@ class NoOpCache {
   async get(_key, _schema) {
     return null;
   }
-  async put(_key, _value, _ttlSeconds) {
+  async put(_key, _value, options) {
     return;
   }
-  async del(_keys) {
+  async invalidate(dependencyIds) {
     return;
   }
-  async keys(_pattern) {
-    return [];
-  }
-  async clear(_pattern) {
+  async clear() {
     return;
   }
-  async getStats() {
-    return {
-      hits: 0,
-      misses: 0,
-      size: 0
-    };
-  }
 }
 export {
   NoOpCache

package/cache/redis-cache.js

@@ -14,45 +14,29 @@ class RedisCache {
     }
     return null;
   }
-  async put(key, value, ttlSeconds) {
+  async put(key, value, options) {
     if (!key) {
       return;
     }
-    const options = ttlSeconds ? { ex: ttlSeconds } : void 0;
-    await this.redis.set(key, value, options);
-  }
-  async del(keys) {
-    const keyArray = Array.isArray(keys) ? keys : [keys];
-    for (const key of keyArray) {
-      if (key.includes("*")) {
-        const matchingKeys = await this.redis.keys(key);
-        if (matchingKeys.length > 0) {
-          await this.redis.del(...matchingKeys);
-        }
-      } else {
-        await this.redis.del(key);
-      }
+    const serialized = JSON.stringify(value);
+    const multi = this.redis.multi();
+    multi.set(key, serialized, { ex: options.ttlSeconds });
+    for (const depId of options.dependencyIds) {
+      multi.sadd(`dep:${depId}`, key);
     }
+    await multi.exec();
   }
-  async keys(pattern) {
-    return await this.redis.keys(pattern);
-  }
-  async clear(pattern) {
-    const searchPattern = pattern || "*";
-    const keys = await this.redis.keys(searchPattern);
-    if (keys.length > 0) {
-      await this.redis.del(...keys);
+  async invalidate(dependencyIds) {
+    for (const id of dependencyIds) {
+      const depKey = `dep:${id}`;
+      const keys = await this.redis.smembers(depKey);
+      if (keys.length > 0) {
+        await this.redis.del(...keys);
+      }
+      await this.redis.del(depKey);
     }
   }
-  async getStats() {
-    const keys = await this.redis.keys("*");
-    return {
-      hits: 0,
-      // Would need to track this separately
-      misses: 0,
-      // Would need to track this separately  
-      size: keys.length
-    };
+  async clear() {
   }
 }
 export {

package/decorators/reactionary.decorator.js

@@ -1,13 +1,66 @@
+import { getTracer, SpanKind } from "@reactionary/otel";
+class ReactionaryDecoratorOptions {
+  constructor() {
+    /**
+     * Whether or not the query is eligible for caching. Queries that depend
+     * heavily on personalization, for example, are likely to be a poor fit
+     * for caching.
+     */
+    this.cache = false;
+    /**
+     * Whether or not the cache entry should be variable based on the locale
+     * of the context in which it is querried.
+     */
+    this.localeDependentCaching = false;
+    /**
+     * Whether or not the cache entry should be variable based on the currency
+     * of the context in which it is querried.
+     */
+    this.currencyDependentCaching = false;
+    /**
+     * The number of seconds which a cache entry should be considered valid for the
+     * given query.
+     */
+    this.cacheTimeToLiveInSeconds = 60;
+  }
+}
+;
 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);
+    const scope = `${target.constructor.name}.${propertyKey.toString()}`;
+    const configuration = { ...new ReactionaryDecoratorOptions(), ...options };
+    if (!original) {
+      throw new Error(
+        "@Reactionary decorator may only be applied to methods on classes extending BaseProvider."
+      );
+    }
+    descriptor.value = async function(...args) {
+      const tracer = getTracer();
+      return tracer.startActiveSpan(
+        propertyKey.toString(),
+        { kind: SpanKind.SERVER },
+        async (span) => {
+          const cacheKey = this.generateCacheKeyForQuery(scope, args[0]);
+          const fromCache = await this.cache.get(cacheKey, this.schema);
+          let result = fromCache;
+          if (!result) {
+            result = await original.apply(this, args);
+            const dependencyIds = this.generateDependencyIdsForModel(result);
+            this.cache.put(cacheKey, result, {
+              ttlSeconds: configuration.cacheTimeToLiveInSeconds,
+              dependencyIds
+            });
+          }
+          span.end();
+          return this.assert(result);
+        }
+      );
     };
     return descriptor;
   };
 }
 export {
-  Reactionary
+  Reactionary,
+  ReactionaryDecoratorOptions
 };

package/index.js

@@ -1,36 +1,14 @@
 export * from "./cache/cache.interface";
-export * from "./cache/cache-evaluation.interface";
 export * from "./cache/redis-cache";
+export * from "./cache/memory-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";
-export * from "./providers/identity.provider";
-export * from "./providers/inventory.provider";
-export * from "./providers/price.provider";
-export * from "./providers/product.provider";
-export * from "./providers/search.provider";
-export * from "./providers/category.provider";
+export * from "./providers/";
 export * from "./schemas/capabilities.schema";
 export * from "./schemas/session.schema";
-export * from "./schemas/models/base.model";
-export * from "./schemas/models/cart.model";
-export * from "./schemas/models/currency.model";
-export * from "./schemas/models/identifiers.model";
-export * from "./schemas/models/identity.model";
-export * from "./schemas/models/inventory.model";
-export * from "./schemas/models/price.model";
-export * from "./schemas/models/product.model";
-export * from "./schemas/models/search.model";
-export * from "./schemas/models/category.model";
-export * from "./schemas/mutations/base.mutation";
-export * from "./schemas/mutations/cart.mutation";
-export * from "./schemas/mutations/identity.mutation";
-export * from "./schemas/mutations/inventory.mutation";
-export * from "./schemas/mutations/price.mutation";
-export * from "./schemas/mutations/product.mutation";
-export * from "./schemas/mutations/search.mutation";
+export * from "./schemas/models/";
+export * from "./schemas/mutations/";
 export * from "./schemas/queries";
+export * from "./initialization";

package/initialization.js

@@ -0,0 +1,43 @@
+function createInitialRequestContext() {
+  return {
+    id: "",
+    identity: {
+      type: "Anonymous",
+      meta: {
+        cache: { hit: false, key: "" },
+        placeholder: false
+      },
+      id: { userId: "anonymous" },
+      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-US",
+      currencyCode: "USD"
+    },
+    storeIdentifier: {
+      key: "the-good-store"
+    },
+    taxJurisdiction: {
+      countryCode: "US",
+      stateCode: "",
+      countyCode: "",
+      cityCode: ""
+    },
+    session: {},
+    correlationId: "",
+    isBot: false,
+    clientIp: "",
+    userAgent: "",
+    referrer: ""
+  };
+}
+export {
+  createInitialRequestContext
+};

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@reactionary/core",
-  "version": "0.0.41",
+  "version": "0.0.48",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
     "zod": "4.1.9",
-    "@upstash/redis": "^1.34.9"
+    "@upstash/redis": "^1.34.9",
+    "@reactionary/otel": "0.0.48",
+    "node-object-hash": "^3.1.1"
   }
 }

package/providers/base.provider.js

@@ -1,4 +1,7 @@
-import { createPaginatedResponseSchema } from "../schemas/models/base.model";
+import {
+  createPaginatedResponseSchema
+} from "../schemas/models/base.model";
+import { hasher } from "node-object-hash";
 class BaseProvider {
   constructor(schema, cache) {
     this.schema = schema;
@@ -21,26 +24,40 @@ class BaseProvider {
    * Handler for parsing a response from a remote provider and converting it
    * into the typed domain model.
    */
-  parseSingle(_body, session) {
+  parseSingle(_body, reqCtx) {
     const model = this.newModel();
     return this.assert(model);
   }
-  parsePaginatedResult(_body, session) {
+  parsePaginatedResult(_body, reqCtx) {
     return createPaginatedResponseSchema(this.schema).parse({});
   }
-  generateCacheKeyPaginatedResult(resultSetName, res, session) {
+  generateDependencyIdsForModel(model) {
+    const identifier = model?.identifier;
+    if (!identifier) {
+      return [];
+    }
+    const h = hasher({ sort: true, coerce: false });
+    const hash = h.hash(identifier);
+    return [hash];
+  }
+  generateCacheKeyForQuery(scope, query) {
+    const h = hasher({ sort: true, coerce: false });
+    const queryHash = h.hash(query);
+    return `${scope}:${queryHash}`;
+  }
+  generateCacheKeyPaginatedResult(resultSetName, res, reqCtx) {
     const type = this.getResourceName();
-    const langPart = session.languageContext.locale;
-    const currencyPart = session.languageContext.currencyCode || "default";
-    const storePart = session.storeIdentifier?.key || "default";
+    const langPart = reqCtx.languageContext.locale;
+    const currencyPart = reqCtx.languageContext.currencyCode || "default";
+    const storePart = reqCtx.storeIdentifier?.key || "default";
     return `${type}-${resultSetName}-paginated|pageNumber:${res.pageNumber}|pageSize:${res.pageSize}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
   }
-  generateCacheKeySingle(identifier, session) {
+  generateCacheKeySingle(identifier, reqCtx) {
     const type = this.getResourceName();
-    const idPart = Object.entries(identifier).map(([k, v]) => `${k}:${v.key}`).join("#");
-    const langPart = session.languageContext.locale;
-    const currencyPart = session.languageContext.currencyCode || "default";
-    const storePart = session.storeIdentifier?.key || "default";
+    const idPart = Object.entries(identifier).map(([k, v]) => `${k}:${v}`).join("#");
+    const langPart = reqCtx.languageContext.locale;
+    const currencyPart = reqCtx.languageContext.currencyCode || "default";
+    const storePart = reqCtx.storeIdentifier?.key || "default";
     return `${type}-${idPart}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
   }
 }

package/providers/cart-payment.provider.js

@@ -0,0 +1,9 @@
+import { BaseProvider } from "./base.provider";
+class CartPaymentProvider extends BaseProvider {
+  getResourceName() {
+    return "cart-payment-instruction";
+  }
+}
+export {
+  CartPaymentProvider
+};

package/providers/cart.provider.js

@@ -1,5 +1,11 @@
 import { BaseProvider } from "./base.provider";
 class CartProvider extends BaseProvider {
+  createEmptyCart() {
+    const cart = this.newModel();
+    cart.meta = { placeholder: true, cache: { hit: true, key: "empty-cart" } };
+    cart.identifier = { key: "" };
+    return cart;
+  }
   getResourceName() {
     return "cart";
   }

package/providers/index.js

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

package/providers/price.provider.js

@@ -8,7 +8,7 @@ class PriceProvider extends BaseProvider {
    * @param currency
    * @returns
    */
-  getEmptyPriceResult(sku, currency) {
+  createEmptyPriceResult(sku, currency) {
     const base = this.newModel();
     base.identifier = {
       sku: { key: sku }

package/providers/product.provider.js

@@ -1,5 +1,15 @@
 import { BaseProvider } from "./base.provider";
 class ProductProvider extends BaseProvider {
+  createEmptyProduct(id) {
+    const product = this.newModel();
+    product.identifier = { key: id };
+    product.meta.placeholder = true;
+    return product;
+  }
+  /**
+   * The resource name, used for caching and logging.
+   * @returns
+   */
   getResourceName() {
     return "product";
   }

package/providers/profile.provider.js

@@ -0,0 +1,9 @@
+import { BaseProvider } from "./base.provider";
+class ProfileProvider extends BaseProvider {
+  getResourceName() {
+    return "profile";
+  }
+}
+export {
+  ProfileProvider
+};

package/providers/store.provider.js

@@ -0,0 +1,9 @@
+import { BaseProvider } from "./base.provider";
+class StoreProvider extends BaseProvider {
+  getResourceName() {
+    return "store";
+  }
+}
+export {
+  StoreProvider
+};

package/schemas/capabilities.schema.js

@@ -5,9 +5,11 @@ const CapabilitiesSchema = z.looseObject({
   analytics: z.boolean(),
   identity: z.boolean(),
   cart: z.boolean(),
+  cartPayment: z.boolean(),
   inventory: z.boolean(),
   price: z.boolean(),
-  category: z.boolean()
+  category: z.boolean(),
+  store: z.boolean()
 });
 export {
   CapabilitiesSchema

package/schemas/models/cart.model.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
-import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from "../models/identifiers.model";
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, ProductIdentifierSchema, SKUIdentifierSchema } from "../models/identifiers.model";
 import { BaseModelSchema } from "./base.model";
 import { MonetaryAmountSchema } from "./price.model";
+import { AddressSchema } from "./profile.model";
+import { ShippingMethodSchema } from "./shipping-method.model";
 const CostBreakDownSchema = z.looseObject({
   totalTax: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of tax paid on the cart. This may include VAT, GST, sales tax, etc."),
   totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of discount applied to the cart."),
@@ -19,15 +21,20 @@ const ItemCostBreakdownSchema = z.looseObject({
 const CartItemSchema = z.looseObject({
   identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
   product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
   quantity: z.number().default(0),
   price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({}))
 });
 const CartSchema = BaseModelSchema.extend({
   identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  userId: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
   items: z.array(CartItemSchema).default(() => []),
   price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
   name: z.string().default(""),
-  description: z.string().default("")
+  description: z.string().default(""),
+  shippingAddress: AddressSchema.optional(),
+  billingAddress: AddressSchema.optional(),
+  shippingMethod: ShippingMethodSchema.optional()
 });
 export {
   CartItemSchema,

package/schemas/models/identifiers.model.js

@@ -30,27 +30,63 @@ const PriceIdentifierSchema = z.looseObject({
 const CategoryIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
+const StoreIdentifierSchema = z.looseObject({
+  key: z.string().default("").optional()
+});
+const OrderIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
+const OrderItemIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
 const WebStoreIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
-const InventoryChannelIdentifierSchema = z.looseObject({
-  key: z.string().default("online").nonoptional()
+const FulfillmentCenterIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
 });
 const InventoryIdentifierSchema = z.looseObject({
   sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
-  channelId: InventoryChannelIdentifierSchema.default(() => InventoryChannelIdentifierSchema.parse({}))
+  fulfillmentCenter: FulfillmentCenterIdentifierSchema.default(
+    () => FulfillmentCenterIdentifierSchema.parse({})
+  )
+});
+const IdentityIdentifierSchema = z.looseObject({
+  userId: z.string().default("").nonoptional()
+});
+const ShippingMethodIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
+const PaymentMethodIdentifierSchema = z.looseObject({
+  method: z.string().default("").nonoptional(),
+  name: z.string().default("").nonoptional(),
+  paymentProcessor: z.string().default("").nonoptional()
+});
+const AddressIdentifierSchema = z.looseObject({
+  nickName: z.string().default("").nonoptional()
+});
+const PaymentInstructionIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
 });
 export {
+  AddressIdentifierSchema,
   CartIdentifierSchema,
   CartItemIdentifierSchema,
   CategoryIdentifierSchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
-  InventoryChannelIdentifierSchema,
+  FulfillmentCenterIdentifierSchema,
+  IdentityIdentifierSchema,
   InventoryIdentifierSchema,
+  OrderIdentifierSchema,
+  OrderItemIdentifierSchema,
+  PaymentInstructionIdentifierSchema,
+  PaymentMethodIdentifierSchema,
   PriceIdentifierSchema,
   ProductIdentifierSchema,
   SKUIdentifierSchema,
   SearchIdentifierSchema,
+  ShippingMethodIdentifierSchema,
+  StoreIdentifierSchema,
   WebStoreIdentifierSchema
 };

package/schemas/models/identity.model.js

@@ -1,14 +1,28 @@
 import { z } from "zod";
 import { BaseModelSchema } from "./base.model";
-const IdentityTypeSchema = z.enum(["Anonymous", "Guest", "Registered"]);
-const IdentitySchema = BaseModelSchema.extend({
-  id: z.string().default(""),
-  type: IdentityTypeSchema.default("Anonymous"),
+import { IdentityIdentifierSchema } from "./identifiers.model";
+const AnonymousIdentitySchema = BaseModelSchema.extend({
+  type: z.literal("Anonymous")
+});
+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(/* @__PURE__ */ new Date())
+});
+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(/* @__PURE__ */ new Date()),
+  refresh_token: z.string().optional(),
   expiry: z.coerce.date().default(/* @__PURE__ */ new Date())
 });
+const IdentitySchema = z.discriminatedUnion("type", [AnonymousIdentitySchema, GuestIdentitySchema, RegisteredIdentitySchema]);
 export {
+  AnonymousIdentitySchema,
+  GuestIdentitySchema,
   IdentitySchema,
-  IdentityTypeSchema
+  RegisteredIdentitySchema
 };

package/schemas/models/index.js

@@ -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/schemas/models/payment.model.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { BaseModelSchema, ImageSchema } from "./base.model";
+import { CartIdentifierSchema, PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from "./identifiers.model";
+import { MonetaryAmountSchema } from "./price.model";
+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("")
+});
+const PaymentMethodSchema = BaseModelSchema.extend({
+  identifier: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+  logo: ImageSchema.optional(),
+  description: z.string().default(""),
+  isPunchOut: z.boolean().default(true)
+});
+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")
+});
+const CartPaymentInstructionSchema = PaymentInstructionSchema.extend({
+  cart: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({}))
+});
+const OrderPaymentInstructionSchema = PaymentInstructionSchema.extend({
+  order: z.string().default("")
+  // OrderIdentifierSchema
+});
+export {
+  CartPaymentInstructionSchema,
+  OrderPaymentInstructionSchema,
+  PaymentInstructionSchema,
+  PaymentMethodSchema,
+  PaymentProtocolDataSchema,
+  PaymentStatusSchema
+};