@reactionary/core 0.0.42 → 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,6 +1,6 @@
 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";
@@ -11,3 +11,4 @@ export * from "./schemas/session.schema";
 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.42",
+  "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/index.js

@@ -7,4 +7,6 @@ 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/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

@@ -8,7 +8,8 @@ const CapabilitiesSchema = z.looseObject({
   cartPayment: z.boolean(),
   inventory: z.boolean(),
   price: z.boolean(),
-  category: z.boolean()
+  category: z.boolean(),
+  store: z.boolean()
 });
 export {
   CapabilitiesSchema

package/schemas/models/identifiers.model.js

@@ -30,6 +30,9 @@ 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()
 });
@@ -39,17 +42,19 @@ const OrderItemIdentifierSchema = z.looseObject({
 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 ShippingMethodIdentifier = z.looseObject({
+const ShippingMethodIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
 const PaymentMethodIdentifierSchema = z.looseObject({
@@ -70,8 +75,8 @@ export {
   CategoryIdentifierSchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
+  FulfillmentCenterIdentifierSchema,
   IdentityIdentifierSchema,
-  InventoryChannelIdentifierSchema,
   InventoryIdentifierSchema,
   OrderIdentifierSchema,
   OrderItemIdentifierSchema,
@@ -81,6 +86,7 @@ export {
   ProductIdentifierSchema,
   SKUIdentifierSchema,
   SearchIdentifierSchema,
-  ShippingMethodIdentifier,
+  ShippingMethodIdentifierSchema,
+  StoreIdentifierSchema,
   WebStoreIdentifierSchema
 };

package/schemas/models/identity.model.js

@@ -1,29 +1,28 @@
 import { z } from "zod";
 import { BaseModelSchema } from "./base.model";
 import { IdentityIdentifierSchema } from "./identifiers.model";
-const IdentityTypeSchema = z.enum(["Anonymous", "Guest", "Registered"]);
-const ServiceTokenSchema = z.object({
-  service: z.string().default(""),
-  token: z.string().default(""),
-  issued: z.coerce.date().default(/* @__PURE__ */ new Date()),
+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 IdentitySchema = BaseModelSchema.extend({
+const RegisteredIdentitySchema = BaseModelSchema.extend({
   id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-  type: IdentityTypeSchema.default("Anonymous"),
+  type: z.literal("Registered"),
   logonId: z.string().default(""),
-  createdAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
-  updatedAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
-  // Tokens for various services
-  keyring: z.array(ServiceTokenSchema).default(() => []),
-  // Deprecated - use serviceTokens map instead
-  currentService: z.string().optional(),
   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,
-  ServiceTokenSchema
+  RegisteredIdentitySchema
 };

package/schemas/models/index.js

@@ -12,3 +12,4 @@ export * from "./product.model";
 export * from "./profile.model";
 export * from "./search.model";
 export * from "./shipping-method.model";
+export * from "./store.model";

package/schemas/models/profile.model.js

@@ -1,6 +1,7 @@
 import z from "zod";
 import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model";
-const AddressSchema = z.looseObject({
+import { BaseModelSchema } from "./base.model";
+const AddressSchema = BaseModelSchema.extend({
   identifier: AddressIdentifierSchema.default(() => AddressIdentifierSchema.parse({})),
   firstName: z.string().default(""),
   lastName: z.string().default(""),
@@ -11,7 +12,7 @@ const AddressSchema = z.looseObject({
   postalCode: z.string().default(""),
   countryCode: z.string().default("US")
 });
-const ProfileSchema = z.looseObject({
+const ProfileSchema = BaseModelSchema.extend({
   identifier: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
   email: z.string().email().default(""),
   phone: z.string().default(""),

package/schemas/models/shipping-method.model.js

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

package/schemas/models/store.model.js

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

package/schemas/mutations/cart.mutation.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { BaseMutationSchema } from "./base.mutation";
-import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifier, SKUIdentifierSchema } from "../models/identifiers.model";
+import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifierSchema, SKUIdentifierSchema } from "../models/identifiers.model";
 import { AddressSchema } from "../models/profile.model";
 import { CurrencySchema } from "../models/currency.model";
 import { MonetaryAmountSchema } from "../models/price.model";
@@ -23,7 +23,7 @@ const CartMutationDeleteCartSchema = BaseMutationSchema.extend({
 });
 const CartMutationSetShippingInfoSchema = BaseMutationSchema.extend({
   cart: CartIdentifierSchema.required(),
-  shippingMethod: ShippingMethodIdentifier.optional(),
+  shippingMethod: ShippingMethodIdentifierSchema.optional(),
   shippingAddress: AddressSchema.optional()
 });
 const CartMutationSetBillingAddressSchema = BaseMutationSchema.extend({

package/schemas/mutations/identity.mutation.js

@@ -5,7 +5,12 @@ const IdentityMutationLoginSchema = BaseMutationSchema.extend({
   password: z.string()
 });
 const IdentityMutationLogoutSchema = BaseMutationSchema.extend({});
+const IdentityMutationRegisterSchema = BaseMutationSchema.extend({
+  username: z.string(),
+  password: z.string()
+});
 export {
   IdentityMutationLoginSchema,
-  IdentityMutationLogoutSchema
+  IdentityMutationLogoutSchema,
+  IdentityMutationRegisterSchema
 };

package/schemas/mutations/index.js

@@ -6,4 +6,5 @@ export * from "./identity.mutation";
 export * from "./inventory.mutation";
 export * from "./price.mutation";
 export * from "./product.mutation";
+export * from "./profile.mutation";
 export * from "./search.mutation";

package/schemas/mutations/profile.mutation.js

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

package/schemas/queries/index.js

@@ -7,4 +7,6 @@ export * from "./identity.query";
 export * from "./inventory.query";
 export * from "./price.query";
 export * from "./product.query";
+export * from "./profile.query";
 export * from "./search.query";
+export * from "./store.query";

package/schemas/queries/inventory.query.js

@@ -1,11 +1,9 @@
-import { z } from "zod";
 import { BaseQuerySchema } from "./base.query";
-import { ProductIdentifierSchema } from "../models/identifiers.model";
+import { FulfillmentCenterIdentifierSchema, ProductIdentifierSchema } from "../models/identifiers.model";
 const InventoryQueryBySKUSchema = BaseQuerySchema.extend({
-  query: z.literal("sku"),
-  sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
+  sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})).nonoptional(),
+  fulfilmentCenter: FulfillmentCenterIdentifierSchema.default(() => FulfillmentCenterIdentifierSchema.parse({})).nonoptional()
 });
-;
 export {
   InventoryQueryBySKUSchema
 };

package/schemas/queries/profile.query.js

@@ -0,0 +1,5 @@
+import { BaseQuerySchema } from "./base.query";
+const ProfileQuerySelfSchema = BaseQuerySchema.extend({});
+export {
+  ProfileQuerySelfSchema
+};

package/schemas/queries/store.query.js

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