@reactionary/core 0.0.42 → 0.0.51

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.51",
   "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.51",
+    "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/checkout.provider.js

@@ -0,0 +1,6 @@
+import { BaseProvider } from "./base.provider";
+class CheckoutProvider extends BaseProvider {
+}
+export {
+  CheckoutProvider
+};

package/providers/index.js

@@ -1,10 +1,13 @@
 export * from "./analytics.provider";
 export * from "./base.provider";
-export * from "./cart-payment.provider";
 export * from "./cart.provider";
 export * from "./category.provider";
+export * from "./checkout.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";
+export * from "./order.provider";

package/providers/order.provider.js

@@ -0,0 +1,15 @@
+import { BaseProvider } from "./base.provider";
+class OrderProvider extends BaseProvider {
+  createEmptyOrder() {
+    const order = this.newModel();
+    order.meta = { placeholder: true, cache: { hit: true, key: "empty-order" } };
+    order.identifier = { key: "" };
+    return order;
+  }
+  getResourceName() {
+    return "order";
+  }
+}
+export {
+  OrderProvider
+};

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,10 +5,12 @@ const CapabilitiesSchema = z.looseObject({
   analytics: z.boolean(),
   identity: z.boolean(),
   cart: z.boolean(),
-  cartPayment: z.boolean(),
+  checkout: z.boolean(),
+  order: 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,23 +1,7 @@
 import { z } from "zod";
 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."),
-  totalSurcharge: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of surcharge applied to the cart."),
-  totalShipping: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of shipping fees for the cart."),
-  totalProductPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price of products in the cart."),
-  grandTotal: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price for the cart including all taxes, discounts, and shipping.")
-});
-const ItemCostBreakdownSchema = z.looseObject({
-  unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The price per single unit of the item."),
-  unitDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The discount applied per single unit of the item."),
-  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.")
-});
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model";
 const CartItemSchema = z.looseObject({
   identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
   product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
@@ -31,14 +15,9 @@ const CartSchema = BaseModelSchema.extend({
   items: z.array(CartItemSchema).default(() => []),
   price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
   name: z.string().default(""),
-  description: z.string().default(""),
-  shippingAddress: AddressSchema.optional(),
-  billingAddress: AddressSchema.optional(),
-  shippingMethod: ShippingMethodSchema.optional()
+  description: z.string().default("")
 });
 export {
   CartItemSchema,
-  CartSchema,
-  CostBreakDownSchema,
-  ItemCostBreakdownSchema
+  CartSchema
 };

package/schemas/models/checkout.model.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { BaseModelSchema } from "./base.model";
+import { CartIdentifierSchema, CheckoutIdentifierSchema, CheckoutItemIdentifierSchema, OrderIdentifierSchema, SKUIdentifierSchema } from "./identifiers.model";
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model";
+import { AddressSchema } from "./profile.model";
+import { ShippingInstructionSchema } from "./shipping-method.model";
+import { PaymentInstructionSchema } from "./payment.model";
+const CheckoutItemSchema = z.looseObject({
+  identifier: CheckoutItemIdentifierSchema.default(() => CheckoutItemIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+  quantity: z.number().default(0),
+  price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({}))
+});
+const CheckoutSchema = BaseModelSchema.extend({
+  identifier: CheckoutIdentifierSchema.default(() => CheckoutIdentifierSchema.parse({})),
+  /**
+   * Do we need this?
+   */
+  originalCartReference: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  /**
+   * If the checkout has been completed, this will point to the resulting order.
+   */
+  resultingOrder: OrderIdentifierSchema.optional(),
+  items: z.array(CheckoutItemSchema).default(() => []),
+  price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
+  name: z.string().default(""),
+  description: z.string().default(""),
+  billingAddress: AddressSchema.optional(),
+  /**
+   * Shipping and billing details can be changed on the checkout, but not items or quantities.
+   */
+  shippingAddress: AddressSchema.optional(),
+  shippingInstruction: ShippingInstructionSchema.optional(),
+  paymentInstructions: z.array(PaymentInstructionSchema).default(() => []),
+  /**
+   * Indicates if the checkout has all the required information to be finalized into an order.
+   * This does not mean it will succeed, as there may be issues with payment or shipping, but all required information is present.
+   */
+  readyForFinalization: z.boolean().default(false).describe("Indicates if the checkout has all the required information to be finalized into an order. This does not mean it will succeed, as there may be issues with payment or shipping, but all required information is present.")
+});
+export {
+  CheckoutItemSchema,
+  CheckoutSchema
+};

package/schemas/models/cost.model.js

@@ -0,0 +1,20 @@
+import z from "zod";
+import { MonetaryAmountSchema } from "./price.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."),
+  totalSurcharge: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of surcharge applied to the cart."),
+  totalShipping: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of shipping fees for the cart."),
+  totalProductPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price of products in the cart."),
+  grandTotal: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price for the cart including all taxes, discounts, and shipping.")
+});
+const ItemCostBreakdownSchema = z.looseObject({
+  unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The price per single unit of the item."),
+  unitDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The discount applied per single unit of the item."),
+  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.")
+});
+export {
+  CostBreakDownSchema,
+  ItemCostBreakdownSchema
+};

package/schemas/models/identifiers.model.js

@@ -30,26 +30,37 @@ 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 CheckoutIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
+const CheckoutItemIdentifierSchema = 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 ShippingMethodIdentifier = z.looseObject({
+const ShippingMethodIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
 const PaymentMethodIdentifierSchema = z.looseObject({
@@ -63,24 +74,31 @@ const AddressIdentifierSchema = z.looseObject({
 const PaymentInstructionIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
+const PickupPointIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
 export {
   AddressIdentifierSchema,
   CartIdentifierSchema,
   CartItemIdentifierSchema,
   CategoryIdentifierSchema,
+  CheckoutIdentifierSchema,
+  CheckoutItemIdentifierSchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
+  FulfillmentCenterIdentifierSchema,
   IdentityIdentifierSchema,
-  InventoryChannelIdentifierSchema,
   InventoryIdentifierSchema,
   OrderIdentifierSchema,
   OrderItemIdentifierSchema,
   PaymentInstructionIdentifierSchema,
   PaymentMethodIdentifierSchema,
+  PickupPointIdentifierSchema,
   PriceIdentifierSchema,
   ProductIdentifierSchema,
   SKUIdentifierSchema,
   SearchIdentifierSchema,
-  ShippingMethodIdentifier,
+  ShippingMethodIdentifierSchema,
+  StoreIdentifierSchema,
   WebStoreIdentifierSchema
 };

package/schemas/models/identity.model.js

@@ -1,29 +1,31 @@
 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").default("Anonymous"),
+  token: z.string().optional(),
+  refresh_token: z.string().optional(),
+  expiry: z.coerce.date().default(/* @__PURE__ */ new Date())
+});
+const GuestIdentitySchema = BaseModelSchema.extend({
+  id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+  type: z.literal("Guest").default("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").default("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,8 @@ export * from "./product.model";
 export * from "./profile.model";
 export * from "./search.model";
 export * from "./shipping-method.model";
+export * from "./store.model";
+export * from "./order.model";
+export * from "./cost.model";
+export * from "./checkout.model";
+export * from "./payment.model";