@reactionary/core 0.0.27

package/README.md

@@ -0,0 +1,11 @@
+# core
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build core` to build the library.
+
+## Running unit tests
+
+Run `nx test core` to execute the unit tests via [Vitest](https://vitest.dev/).

package/index.js

@@ -0,0 +1,647 @@
+// core/src/cache/caching-strategy.ts
+var BaseCachingStrategy = class {
+  get(query, session) {
+    const q = query;
+    return {
+      key: q.sku,
+      cacheDurationInSeconds: 300,
+      canCache: true
+    };
+  }
+};
+
+// core/src/cache/redis-cache.ts
+import { Redis } from "@upstash/redis";
+var RedisCache = class {
+  constructor(strategy) {
+    this.strategy = strategy;
+    this.redis = Redis.fromEnv();
+  }
+  async get(query, session, schema) {
+    let result = null;
+    const cacheInformation = this.strategy.get(query, session);
+    if (cacheInformation.canCache && cacheInformation.key) {
+      const unvalidated = await this.redis.get(cacheInformation.key);
+      const parsed = schema.safeParse(unvalidated);
+      if (parsed.success) {
+        result = parsed.data;
+      }
+    }
+    return result;
+  }
+  put(query, session, value) {
+    const cacheInformation = this.strategy.get(query, session);
+    if (cacheInformation.canCache && cacheInformation.key) {
+      this.redis.set(cacheInformation.key, value, { ex: cacheInformation.cacheDurationInSeconds });
+    }
+  }
+};
+
+// core/src/client/client.ts
+function buildClient(providers) {
+  let client = {};
+  const mergedAnalytics = [];
+  for (const provider of providers) {
+    client = {
+      ...client,
+      ...provider
+    };
+    if (provider.analytics) {
+      mergedAnalytics.push(...provider.analytics);
+    }
+  }
+  client.analytics = mergedAnalytics;
+  return client;
+}
+
+// core/src/providers/base.provider.ts
+var BaseProvider = class {
+  constructor(schema, querySchema, mutationSchema) {
+    this.schema = schema;
+    this.querySchema = querySchema;
+    this.mutationSchema = mutationSchema;
+  }
+  /**
+   * 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({});
+  }
+  /**
+   * Retrieves a set of entities matching the list of queries. The size of
+   * the resulting list WILL always match the size of the query list. The
+   * result list will never contain nulls or undefined. The order
+   * of the results will match the order of the queries.
+   */
+  async query(queries, session) {
+    const results = await this.fetch(queries, session);
+    for (const result of results) {
+      this.assert(result);
+    }
+    return results;
+  }
+  /**
+   * Executes the listed mutations in order and returns the final state
+   * resulting from that set of operations.
+   */
+  async mutate(mutations, session) {
+    const result = await this.process(mutations, session);
+    this.assert(result);
+    return result;
+  }
+};
+
+// core/src/providers/analytics.provider.ts
+var AnalyticsProvider = class extends BaseProvider {
+};
+
+// core/src/providers/cart.provider.ts
+var CartProvider = class extends BaseProvider {
+};
+
+// core/src/providers/identity.provider.ts
+var IdentityProvider = class extends BaseProvider {
+};
+
+// core/src/providers/inventory.provider.ts
+var InventoryProvider = class extends BaseProvider {
+};
+
+// core/src/providers/price.provider.ts
+var PriceProvider = class extends BaseProvider {
+};
+
+// core/src/providers/product.provider.ts
+var ProductProvider = class extends BaseProvider {
+};
+
+// core/src/providers/search.provider.ts
+var SearchProvider = class extends BaseProvider {
+};
+
+// core/src/schemas/capabilities.schema.ts
+import { z } from "zod";
+var CapabilitiesSchema = z.looseInterface({
+  product: z.boolean(),
+  search: z.boolean(),
+  analytics: z.boolean(),
+  identity: z.boolean(),
+  cart: z.boolean(),
+  inventory: z.boolean(),
+  price: z.boolean()
+});
+
+// core/src/schemas/session.schema.ts
+import { z as z4 } from "zod";
+
+// core/src/schemas/models/identity.model.ts
+import { z as z3 } from "zod";
+
+// core/src/schemas/models/base.model.ts
+import { z as z2 } from "zod";
+var CacheInformationSchema = z2.looseInterface({
+  hit: z2.boolean().default(false),
+  key: z2.string().default("")
+});
+var MetaSchema = z2.looseInterface({
+  cache: CacheInformationSchema.default(() => CacheInformationSchema.parse({})),
+  placeholder: z2.boolean().default(false).describe("Whether or not the entity exists in a remote system, or is a default placeholder.")
+});
+var BaseModelSchema = z2.looseInterface({
+  meta: MetaSchema.default(() => MetaSchema.parse({}))
+});
+
+// core/src/schemas/models/identity.model.ts
+var IdentityTypeSchema = z3.enum(["Anonymous", "Guest", "Registered"]);
+var IdentitySchema = BaseModelSchema.extend({
+  id: z3.string().default(""),
+  type: IdentityTypeSchema.default("Anonymous"),
+  token: z3.string().optional(),
+  issued: z3.coerce.date().default(/* @__PURE__ */ new Date()),
+  expiry: z3.coerce.date().default(/* @__PURE__ */ new Date())
+});
+
+// core/src/schemas/session.schema.ts
+var SessionSchema = z4.looseObject({
+  id: z4.string(),
+  identity: IdentitySchema.default(() => IdentitySchema.parse({}))
+});
+
+// core/src/schemas/models/cart.model.ts
+import { z as z6 } from "zod";
+
+// core/src/schemas/models/identifiers.model.ts
+import { z as z5 } from "zod";
+var FacetIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("").nonoptional()
+});
+var FacetValueIdentifierSchema = z5.looseInterface({
+  facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+  key: z5.string().default("")
+});
+var SKUIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("").nonoptional()
+});
+var ProductIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var SearchIdentifierSchema = z5.looseInterface({
+  term: z5.string().default(""),
+  page: z5.number().default(0),
+  pageSize: z5.number().default(20),
+  facets: z5.array(FacetValueIdentifierSchema.required()).default(() => [])
+});
+var CartIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var CartItemIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var PriceIdentifierSchema = z5.looseInterface({
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
+});
+
+// core/src/schemas/models/cart.model.ts
+var CartItemSchema = z6.looseInterface({
+  identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
+  product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  quantity: z6.number().default(0)
+});
+var CartSchema = BaseModelSchema.extend({
+  identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  items: z6.array(CartItemSchema).default(() => [])
+});
+
+// core/src/schemas/models/currency.model.ts
+import { z as z7 } from "zod";
+var CurrencySchema = z7.enum([
+  "AED",
+  "AFN",
+  "ALL",
+  "AMD",
+  "ANG",
+  "AOA",
+  "ARS",
+  "AUD",
+  "AWG",
+  "AZN",
+  "BAM",
+  "BBD",
+  "BDT",
+  "BGN",
+  "BHD",
+  "BIF",
+  "BMD",
+  "BND",
+  "BOB",
+  "BOV",
+  "BRL",
+  "BSD",
+  "BTN",
+  "BWP",
+  "BYN",
+  "BZD",
+  "CAD",
+  "CDF",
+  "CHE",
+  "CHF",
+  "CHW",
+  "CLF",
+  "CLP",
+  "CNY",
+  "COP",
+  "COU",
+  "CRC",
+  "CUC",
+  "CUP",
+  "CVE",
+  "CZK",
+  "DJF",
+  "DKK",
+  "DOP",
+  "DZD",
+  "EGP",
+  "ERN",
+  "ETB",
+  "EUR",
+  "FJD",
+  "FKP",
+  "GBP",
+  "GEL",
+  "GHS",
+  "GIP",
+  "GMD",
+  "GNF",
+  "GTQ",
+  "GYD",
+  "HKD",
+  "HNL",
+  "HRK",
+  "HTG",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "IQD",
+  "IRR",
+  "ISK",
+  "JMD",
+  "JOD",
+  "JPY",
+  "KES",
+  "KGS",
+  "KHR",
+  "KMF",
+  "KPW",
+  "KRW",
+  "KWD",
+  "KYD",
+  "KZT",
+  "LAK",
+  "LBP",
+  "LKR",
+  "LRD",
+  "LSL",
+  "LYD",
+  "MAD",
+  "MDL",
+  "MGA",
+  "MKD",
+  "MMK",
+  "MNT",
+  "MOP",
+  "MRU",
+  "MUR",
+  "MVR",
+  "MWK",
+  "MXN",
+  "MXV",
+  "MYR",
+  "MZN",
+  "NAD",
+  "NGN",
+  "NIO",
+  "NOK",
+  "NPR",
+  "NZD",
+  "OMR",
+  "PAB",
+  "PEN",
+  "PGK",
+  "PHP",
+  "PKR",
+  "PLN",
+  "PYG",
+  "QAR",
+  "RON",
+  "RSD",
+  "RUB",
+  "RWF",
+  "SAR",
+  "SBD",
+  "SCR",
+  "SDG",
+  "SEK",
+  "SGD",
+  "SHP",
+  "SLE",
+  "SLL",
+  "SOS",
+  "SRD",
+  "SSP",
+  "STN",
+  "SYP",
+  "SZL",
+  "THB",
+  "TJS",
+  "TMT",
+  "TND",
+  "TOP",
+  "TRY",
+  "TTD",
+  "TVD",
+  "TWD",
+  "TZS",
+  "UAH",
+  "UGX",
+  "USD",
+  "USN",
+  "UYI",
+  "UYU",
+  "UYW",
+  "UZS",
+  "VED",
+  "VES",
+  "VND",
+  "VUV",
+  "WST",
+  "XAF",
+  "XAG",
+  "XAU",
+  "XBA",
+  "XBB",
+  "XBC",
+  "XBD",
+  "XCD",
+  "XDR",
+  "XOF",
+  "XPD",
+  "XPF",
+  "XPT",
+  "XSU",
+  "XTS",
+  "XUA",
+  "XXX",
+  "YER",
+  "ZAR",
+  "ZMW",
+  "ZWL"
+]);
+
+// core/src/schemas/models/inventory.model.ts
+import { z as z8 } from "zod";
+var InventorySchema = BaseModelSchema.extend({
+  quantity: z8.number().default(0)
+});
+
+// core/src/schemas/models/price.model.ts
+import { z as z9 } from "zod";
+var MonetaryAmountSchema = z9.looseInterface({
+  cents: z9.number().default(0).describe("The monetary amount in cent-precision."),
+  currency: CurrencySchema.default("XXX").describe("The currency associated with the amount, as a ISO 4217 standardized code.")
+});
+var PriceSchema = BaseModelSchema.extend({
+  identifier: PriceIdentifierSchema.default(() => PriceIdentifierSchema.parse({})),
+  value: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({}))
+});
+
+// core/src/schemas/models/product.model.ts
+import { z as z10 } from "zod";
+var SKUSchema = z10.looseInterface({
+  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
+});
+var ProductAttributeSchema = z10.looseInterface({
+  id: z10.string(),
+  name: z10.string(),
+  value: z10.string()
+});
+var ProductSchema = BaseModelSchema.extend({
+  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  name: z10.string().default(""),
+  slug: z10.string().default(""),
+  description: z10.string().default(""),
+  image: z10.string().url().default("https://placehold.co/400"),
+  images: z10.string().url().array().default(() => []),
+  attributes: z10.array(ProductAttributeSchema).default(() => []),
+  skus: z10.array(SKUSchema).default(() => [])
+});
+
+// core/src/schemas/models/search.model.ts
+import { z as z11 } from "zod";
+var SearchResultProductSchema = z11.looseInterface({
+  identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  image: z11.string().url().default("https://placehold.co/400"),
+  slug: z11.string().default("")
+});
+var SearchResultFacetValueSchema = z11.looseInterface({
+  identifier: FacetValueIdentifierSchema.default(() => FacetValueIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  count: z11.number().default(0),
+  active: z11.boolean().default(false)
+});
+var SearchResultFacetSchema = z11.looseInterface({
+  identifier: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  values: z11.array(SearchResultFacetValueSchema).default(() => [])
+});
+var SearchResultSchema = BaseModelSchema.extend({
+  identifier: SearchIdentifierSchema.default(() => SearchIdentifierSchema.parse({})),
+  products: z11.array(SearchResultProductSchema).default(() => []),
+  pages: z11.number().default(0),
+  facets: z11.array(SearchResultFacetSchema).default(() => [])
+});
+
+// core/src/schemas/mutations/base.mutation.ts
+import { z as z12 } from "zod";
+var BaseMutationSchema = z12.looseInterface({
+  mutation: z12.ZodLiteral
+});
+
+// core/src/schemas/mutations/cart.mutation.ts
+import { z as z13 } from "zod";
+var CartMutationItemAddSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("add"),
+  cart: CartIdentifierSchema.required(),
+  product: ProductIdentifierSchema.required(),
+  quantity: z13.number()
+});
+var CartMutationItemRemoveSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("remove"),
+  cart: CartIdentifierSchema.required(),
+  item: CartItemIdentifierSchema.required()
+});
+var CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("adjustQuantity"),
+  cart: CartIdentifierSchema.required(),
+  item: CartItemIdentifierSchema.required(),
+  quantity: z13.number()
+});
+var CartMutationSchema = z13.union([CartMutationItemAddSchema, CartMutationItemRemoveSchema, CartMutationItemQuantityChangeSchema]);
+
+// core/src/schemas/mutations/identity.mutation.ts
+import { z as z14 } from "zod";
+var IdentityMutationLoginSchema = BaseMutationSchema.extend({
+  mutation: z14.literal("login"),
+  username: z14.string(),
+  password: z14.string()
+});
+var IdentityMutationLogoutSchema = BaseMutationSchema.extend({
+  mutation: z14.literal("logout")
+});
+var IdentityMutationSchema = z14.union([IdentityMutationLoginSchema, IdentityMutationLogoutSchema]);
+
+// core/src/schemas/mutations/inventory.mutation.ts
+import { z as z15 } from "zod";
+var InventoryMutationSchema = z15.union([]);
+
+// core/src/schemas/mutations/price.mutation.ts
+import { z as z16 } from "zod";
+var PriceMutationSchema = z16.union([]);
+
+// core/src/schemas/mutations/product.mutation.ts
+import { z as z17 } from "zod";
+var ProductMutationSchema = z17.union([]);
+
+// core/src/schemas/mutations/search.mutation.ts
+import { z as z18 } from "zod";
+var SearchMutationSchema = z18.union([]);
+
+// core/src/schemas/queries/base.query.ts
+import { z as z19 } from "zod";
+var BaseQuerySchema = z19.looseInterface({
+  query: z19.ZodLiteral
+});
+
+// core/src/schemas/queries/cart.query.ts
+import { z as z20 } from "zod";
+var CartQueryByIdSchema = BaseQuerySchema.extend({
+  query: z20.literal("id"),
+  cart: CartIdentifierSchema.required()
+});
+var CartQuerySchema = z20.union([CartQueryByIdSchema]);
+
+// core/src/schemas/queries/identity.query.ts
+import { z as z21 } from "zod";
+var IdentityQuerySelfSchema = BaseQuerySchema.extend({
+  query: z21.literal("self")
+});
+var IdentityQuerySchema = z21.union([IdentityQuerySelfSchema]);
+
+// core/src/schemas/queries/inventory.query.ts
+import { z as z22 } from "zod";
+var InventoryQuerySchema = BaseQuerySchema.extend({
+  query: z22.literal("sku"),
+  sku: z22.string()
+});
+
+// core/src/schemas/queries/price.query.ts
+import { z as z23 } from "zod";
+var PriceQueryBySkuSchema = BaseQuerySchema.extend({
+  query: z23.literal("sku"),
+  sku: SKUIdentifierSchema.required()
+});
+var PriceQuerySchema = z23.union([PriceQueryBySkuSchema]);
+
+// core/src/schemas/queries/product.query.ts
+import { z as z24 } from "zod";
+var ProductQueryBySlugSchema = BaseQuerySchema.extend({
+  query: z24.literal("slug"),
+  slug: z24.string()
+});
+var ProductQueryByIdSchema = BaseQuerySchema.extend({
+  query: z24.literal("id"),
+  id: z24.string()
+});
+var ProductQuerySchema = z24.union([ProductQueryBySlugSchema, ProductQueryByIdSchema]);
+
+// core/src/schemas/queries/search.query.ts
+import { z as z25 } from "zod";
+var SearchQueryByTermSchema = BaseQuerySchema.extend({
+  query: z25.literal("term"),
+  search: SearchIdentifierSchema.required()
+});
+var SearchQuerySchema = z25.union([SearchQueryByTermSchema]);
+export {
+  AnalyticsProvider,
+  BaseCachingStrategy,
+  BaseModelSchema,
+  BaseMutationSchema,
+  BaseProvider,
+  BaseQuerySchema,
+  CacheInformationSchema,
+  CapabilitiesSchema,
+  CartIdentifierSchema,
+  CartItemIdentifierSchema,
+  CartItemSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationSchema,
+  CartProvider,
+  CartQueryByIdSchema,
+  CartQuerySchema,
+  CartSchema,
+  CurrencySchema,
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  IdentityMutationLoginSchema,
+  IdentityMutationLogoutSchema,
+  IdentityMutationSchema,
+  IdentityProvider,
+  IdentityQuerySchema,
+  IdentityQuerySelfSchema,
+  IdentitySchema,
+  IdentityTypeSchema,
+  InventoryMutationSchema,
+  InventoryProvider,
+  InventoryQuerySchema,
+  InventorySchema,
+  MetaSchema,
+  MonetaryAmountSchema,
+  PriceIdentifierSchema,
+  PriceMutationSchema,
+  PriceProvider,
+  PriceQueryBySkuSchema,
+  PriceQuerySchema,
+  PriceSchema,
+  ProductAttributeSchema,
+  ProductIdentifierSchema,
+  ProductMutationSchema,
+  ProductProvider,
+  ProductQueryByIdSchema,
+  ProductQueryBySlugSchema,
+  ProductQuerySchema,
+  ProductSchema,
+  RedisCache,
+  SKUIdentifierSchema,
+  SKUSchema,
+  SearchIdentifierSchema,
+  SearchMutationSchema,
+  SearchProvider,
+  SearchQueryByTermSchema,
+  SearchQuerySchema,
+  SearchResultFacetSchema,
+  SearchResultFacetValueSchema,
+  SearchResultProductSchema,
+  SearchResultSchema,
+  SessionSchema,
+  buildClient
+};

package/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@reactionary/core",
+  "version": "0.0.27",
+  "dependencies": {
+    "zod": "4.0.0-beta.20250430T185432",
+    "@upstash/redis": "^1.34.9"
+  }
+}

package/src/cache/caching-strategy.d.ts

@@ -0,0 +1,13 @@
+import { BaseQuery } from "../schemas/queries/base.query";
+import { Session } from "../schemas/session.schema";
+export interface CachingStrategyEvaluation {
+    key: string;
+    cacheDurationInSeconds: number;
+    canCache: boolean;
+}
+export interface CachingStrategy {
+    get(query: BaseQuery, session: Session): CachingStrategyEvaluation;
+}
+export declare class BaseCachingStrategy implements CachingStrategy {
+    get(query: BaseQuery, session: Session): CachingStrategyEvaluation;
+}

package/src/cache/redis-cache.d.ts

@@ -0,0 +1,13 @@
+import { Redis } from '@upstash/redis';
+import { CachingStrategy } from './caching-strategy';
+import { BaseQuery } from '../schemas/queries/base.query';
+import { Session } from '../schemas/session.schema';
+import { BaseModel } from '../schemas/models/base.model';
+import z from 'zod';
+export declare class RedisCache {
+    protected strategy: CachingStrategy;
+    protected redis: Redis;
+    constructor(strategy: CachingStrategy);
+    get<T extends BaseModel>(query: BaseQuery, session: Session, schema: z.ZodType<T>): Promise<T | null>;
+    put(query: BaseQuery, session: Session, value: unknown): void;
+}

package/src/client/client.d.ts

@@ -0,0 +1,18 @@
+import { AnalyticsProvider } from "../providers/analytics.provider";
+import { ProductProvider } from "../providers/product.provider";
+import { SearchProvider } from "../providers/search.provider";
+import { IdentityProvider } from '../providers/identity.provider';
+import { CartProvider } from "../providers/cart.provider";
+import { PriceProvider } from "../providers/price.provider";
+import { InventoryProvider } from "../providers/inventory.provider";
+export interface Client {
+    product: ProductProvider;
+    search: SearchProvider;
+    identity: IdentityProvider;
+    cache: Cache;
+    cart: CartProvider;
+    analytics: Array<AnalyticsProvider>;
+    price: PriceProvider;
+    inventory: InventoryProvider;
+}
+export declare function buildClient<T extends Partial<Client>>(providers: Array<T>): Required<T>;