@reactionary/source 0.3.5 → 0.3.7

package/core/src/schemas/models/product-recommendations.model.ts

@@ -1,10 +1,25 @@
 import z from "zod";
 import { ProductIdentifierSchema, ProductRecommendationIdentifierSchema, ProductVariantIdentifierSchema } from "./identifiers.model.js";
+import { ProductSearchResultItemSchema } from "./product-search.model.js";
 
-export const ProductRecommendationSchema = z.looseObject({
+export const BaseProductRecommendationSchema = z.looseObject({
     recommendationIdentifier: ProductRecommendationIdentifierSchema.describe('The identifier for the product recommendation, which includes a key and an algorithm and any other vendor specific/instance specific data '),
+});
+
+export const ProductRecommendationIdOnlySchema = BaseProductRecommendationSchema.extend({
+    recommendationReturnType: z.literal('idOnly').describe('The type of recommendation return'),
     product: ProductIdentifierSchema.describe('The identifier for the recommended product.'),
 });
+export const ProductRecommendationProductSearchResultItemSchema = BaseProductRecommendationSchema.extend({
+    recommendationReturnType: z.literal('productSearchResultItem').describe('The type of recommendation return'),
+    product: ProductSearchResultItemSchema.describe('The recommended product, including its identifier, name, slug, and variants. This can be used to display the recommended product directly on the frontend without needing to make an additional request to fetch the product details.'),
+});
 
+export const ProductRecommendationSchema = z.discriminatedUnion('recommendationReturnType', [
+  ProductRecommendationIdOnlySchema,
+  ProductRecommendationProductSearchResultItemSchema
+]);
 
+export type ProductRecommendationIdOnly = z.infer<typeof ProductRecommendationIdOnlySchema>;
+export type ProductRecommendationSearchItem = z.infer<typeof ProductRecommendationProductSearchResultItemSchema>;
 export type ProductRecommendation = z.infer<typeof ProductRecommendationSchema>;

package/core/src/schemas/session.schema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { IdentityIdentifierSchema, WebStoreIdentifierSchema } from './models/identifiers.model.js';
+import { WebStoreIdentifierSchema } from './models/identifiers.model.js';
 import { CurrencySchema } from './models/currency.model.js';
 import { IdentitySchema } from './models/identity.model.js';
 
@@ -14,12 +14,12 @@ export const LanguageContextSchema = z.looseObject( {
 export const IdentityContextSchema = z.looseObject({
     identity: IdentitySchema,
     personalizationKey: z.string(),
-    lastUpdated: z.date()
+    lastUpdated: z.coerce.date()
 });
 
-export const SessionSchema = z.record(z.string(), z.any()).and(z.object({
+export const SessionSchema = z.looseObject({
     identityContext: IdentityContextSchema
-}));
+});
 
 export const TaxJurisdictionSchema = z.object( {
     countryCode: z.string().default('US'),

package/core/src/test/request-context.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { createInitialRequestContext } from "../initialization.js";
+import { RequestContextSchema } from "../schemas/session.schema.js";
+
+describe('Request Context', () => {
+  it('should be able to serialize the request context as a JSON string, and have it parse', async () => {
+    const context = createInitialRequestContext();
+    const contextString = JSON.stringify(context);
+    const reconstructedContext = JSON.parse(contextString);
+    
+    const parse = RequestContextSchema.safeParse(reconstructedContext);
+
+    expect(parse.success).toBe(true);
+  });
+});

package/examples/node/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@reactionary/examples-node",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.5",
-    "@reactionary/provider-commercetools": "0.3.5",
-    "@reactionary/provider-algolia": "0.3.5",
-    "@reactionary/provider-medusa": "0.3.5",
-    "@reactionary/provider-meilisearch": "0.3.5"
+    "@reactionary/core": "0.3.7",
+    "@reactionary/provider-commercetools": "0.3.7",
+    "@reactionary/provider-algolia": "0.3.7",
+    "@reactionary/provider-medusa": "0.3.7",
+    "@reactionary/provider-meilisearch": "0.3.7"
   },
   "type": "module"
 }

package/examples/node/src/capabilities/product-recommendations.spec.ts

@@ -36,6 +36,17 @@ describe.each([PrimaryProvider.MEDUSA])(
       }
 
       expect(result.value.length).toBeGreaterThan(0);
+
+      expect(result.value[0].recommendationReturnType).toBe('productSearchResultItem');
+      if (result.value[0].recommendationReturnType === 'productSearchResultItem') {
+        expect(result.value[0].product.identifier.key).toBeDefined();
+        expect(result.value[0].product.name).toBeDefined();
+        expect(result.value[0].product.slug).toBeDefined();
+        expect(result.value[0].product.variants).toBeDefined();
+        expect(result.value[0].product.variants.length).toBeGreaterThan(0);
+        expect(result.value[0].product.variants[0].variant.sku).toBeDefined();
+        expect(result.value[0].product.variants[0].image.sourceUrl).toBeDefined();
+      }
     });
 
     it('should return an empty result for an unknown collection', async () => {
@@ -76,7 +87,16 @@ describe.each([PrimaryProvider.MEILISEARCH])(
       }
 
       expect(result.value.length).toBeGreaterThan(0);
-      expect(result.value[0].product.key).toBeDefined();
+      expect(result.value[0].recommendationReturnType).toBe('productSearchResultItem');
+      if (result.value[0].recommendationReturnType === 'productSearchResultItem') {
+        expect(result.value[0].product.identifier.key).toBeDefined();
+        expect(result.value[0].product.name).toBeDefined();
+        expect(result.value[0].product.slug).toBeDefined();
+        expect(result.value[0].product.variants).toBeDefined();
+        expect(result.value[0].product.variants.length).toBeGreaterThan(0);
+        expect(result.value[0].product.variants[0].variant.sku).toBeDefined();
+        expect(result.value[0].product.variants[0].image.sourceUrl).toBeDefined();
+      }
       expect(result.value[0].recommendationIdentifier.key).toBeDefined();
     });
 
@@ -122,6 +142,17 @@ describe.each([PrimaryProvider.ALGOLIA])(
       }
 
       expect(result.value.length).toBeGreaterThan(0);
+      expect(result.value[0].recommendationReturnType).toBe('productSearchResultItem');
+      if (result.value[0].recommendationReturnType === 'productSearchResultItem') {
+        expect(result.value[0].product.identifier.key).toBeDefined();
+        expect(result.value[0].product.name).toBeDefined();
+        expect(result.value[0].product.slug).toBeDefined();
+        expect(result.value[0].product.variants).toBeDefined();
+        expect(result.value[0].product.variants.length).toBeGreaterThan(0);
+        expect(result.value[0].product.variants[0].variant.sku).toBeDefined();
+        expect(result.value[0].product.variants[0].image.sourceUrl).toBeDefined();
+      }
+
     });
 
     it('should return an empty result for an unknown sku', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "license": "MIT",
   "private": false,
   "dependencies": {

package/providers/algolia/src/providers/product-recommendations.provider.ts

@@ -8,6 +8,10 @@ import {
   type ProductRecommendationAlgorithmTrendingInCategoryQuery,
   type RequestContext,
   type ProductRecommendationsQuery,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  ProductSearchResultItemVariantSchema,
+  ImageSchema,
 } from '@reactionary/core';
 import {
   liteClient,
@@ -21,12 +25,8 @@ import {
 } from 'algoliasearch/lite';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
 import type { AlgoliaProductRecommendationIdentifier } from '../schema/product-recommendation.schema.js';
+import type { AlgoliaNativeRecord, AlgoliaNativeVariant } from '../schema/search.schema.js';
 
-interface AlgoliaRecommendHit {
-  objectID: string;
-  sku?: string;
-  [key: string]: unknown;
-}
 
 /**
  * AlgoliaProductRecommendationsProvider
@@ -209,7 +209,7 @@ export class AlgoliaProductRecommendationsProvider extends ProductRecommendation
 
   protected parseRecommendation(res: RecommendationsResults, query: ProductRecommendationsQuery) {
     const result = [];
-    for(const hit of res.hits as AlgoliaRecommendHit[]) {
+    for(const hit of res.hits as AlgoliaNativeRecord[]) {
       const recommendationIdentifier = {
         key: res.queryID || 'x',
         algorithm: query.algorithm,
@@ -225,12 +225,40 @@ export class AlgoliaProductRecommendationsProvider extends ProductRecommendation
   /**
    * Maps Algolia recommendation results to ProductRecommendation format
    */
-  protected parseSingle(hit: AlgoliaRecommendHit, recommendationIdentifier: AlgoliaProductRecommendationIdentifier): ProductRecommendation {
+  protected parseSingle(hit: AlgoliaNativeRecord, recommendationIdentifier: AlgoliaProductRecommendationIdentifier): ProductRecommendation {
+
+    const product = this.parseSearchResultItem(hit);
+
     return {
       recommendationIdentifier,
-      product: {
-        key: hit.objectID,
-      },
+      recommendationReturnType: 'productSearchResultItem',
+      product: product,
     } satisfies ProductRecommendation;
   }
+
+
+    protected parseSearchResultItem(body: AlgoliaNativeRecord) {
+      const product = {
+        identifier: { key: body.objectID },
+        name: body.name || body.objectID,
+        slug: body.slug || body.objectID,
+        variants: [ ... (body.variants || []) ].map(variant => this.parseVariant(variant, body)),
+      } satisfies ProductSearchResultItem;
+
+      return product;
+    }
+
+    protected parseVariant(variant: AlgoliaNativeVariant, product: AlgoliaNativeRecord): ProductSearchResultItemVariant {
+        const result = ProductSearchResultItemVariantSchema.parse({
+        variant: {
+          sku: variant.sku
+        },
+        image: ImageSchema.parse({
+          sourceUrl: variant.image,
+          altText: product.name || '',
+        })
+      } satisfies Partial<ProductSearchResultItemVariant>);
+
+      return result;
+    }
 }

package/providers/algolia/src/providers/product-search.provider.ts

@@ -25,19 +25,8 @@ import {
 } from '@reactionary/core';
 import { algoliasearch, type SearchResponse } from 'algoliasearch';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
-import type { AlgoliaProductSearchResult } from '../schema/search.schema.js';
+import type { AlgoliaNativeRecord, AlgoliaNativeVariant, AlgoliaProductSearchResult } from '../schema/search.schema.js';
 
-interface AlgoliaNativeVariant {
-  sku: string;
-  image: string;
-}
-
-interface AlgoliaNativeRecord {
-  objectID: string;
-  slug?:string;
-  name?: string;
-  variants: Array<AlgoliaNativeVariant>;
-}
 
 
 export class AlgoliaProductSearchProvider extends ProductSearchProvider {

package/providers/algolia/src/schema/search.schema.ts

@@ -12,3 +12,16 @@ export const AlgoliaProductSearchResultSchema = ProductSearchResultSchema.extend
 
 export type AlgoliaProductSearchResult = z.infer<typeof AlgoliaProductSearchResultSchema>;
 export type AlgoliaProductSearchIdentifier = z.infer<typeof AlgoliaProductSearchIdentifierSchema>;
+
+
+export interface AlgoliaNativeVariant {
+  sku: string;
+  image: string;
+}
+
+export interface AlgoliaNativeRecord {
+  objectID: string;
+  slug?:string;
+  name?: string;
+  variants: Array<AlgoliaNativeVariant>;
+}

package/providers/medusa/src/core/client.ts

@@ -40,7 +40,7 @@ export class RequestContextTokenStore implements MedusaCustomStorage {
       this.context.session[SESSION_KEY] = {};
     }
     const retVal = this.context.session[SESSION_KEY]
-      ? this.context.session[SESSION_KEY][this.keyPrefix + '_' + key] || null
+      ? (this.context.session[SESSION_KEY] as MedusaSession)[this.keyPrefix + '_' + key] || null
       : null;
     if (debug.enabled) {
       debug(
@@ -49,7 +49,7 @@ export class RequestContextTokenStore implements MedusaCustomStorage {
         }`
       );
     }
-    return Promise.resolve(retVal);
+    return Promise.resolve(retVal as any);
   }
 
   setItem(key: string, value: string): Promise<void> {
@@ -63,7 +63,7 @@ export class RequestContextTokenStore implements MedusaCustomStorage {
         } - Value: ${value}`
       );
     }
-    this.context.session[SESSION_KEY][this.keyPrefix + '_' + key] = value;
+    (this.context.session[SESSION_KEY] as MedusaSession)[this.keyPrefix + '_' + key] = value;
     return Promise.resolve();
   }
 
@@ -74,7 +74,7 @@ export class RequestContextTokenStore implements MedusaCustomStorage {
     if (debug.enabled) {
       debug(`Removing token item for key: ${this.keyPrefix + '_' + key}`);
     }
-    delete this.context.session[SESSION_KEY][this.keyPrefix + '_' + key];
+    delete (this.context.session[SESSION_KEY] as MedusaSession)[this.keyPrefix + '_' + key];
     return Promise.resolve();
   }
 }
@@ -220,12 +220,12 @@ export class MedusaAPI {
 
   public getSessionData(): MedusaSession {
     return this.context.session[SESSION_KEY]
-      ? this.context.session[SESSION_KEY]
+      ? this.context.session[SESSION_KEY] as Partial<MedusaSession>
       : MedusaSessionSchema.parse({});
   }
 
   public setSessionData(sessionData: Partial<MedusaSession>): void {
-    const existingData = this.context.session[SESSION_KEY];
+    const existingData = this.context.session[SESSION_KEY] as Partial<MedusaSession>;
 
     this.context.session[SESSION_KEY] = {
       ...existingData,

package/providers/medusa/src/providers/product-recommendations.provider.ts

@@ -1,14 +1,20 @@
+import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
 import {
-  type Cache,
+  error,
+  ImageSchema,
   ProductRecommendationsProvider,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  success,
+  type Cache,
+  type NotFoundError,
   type ProductRecommendation,
   type ProductRecommendationsByCollectionQuery,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  type ProductVariantIdentifier,
   type RequestContext,
-  type Result,
-  success, error,
-  NotFoundErrorSchema,
-  type NotFoundError,
-  errorToString,
+  type Result
 } from '@reactionary/core';
 import createDebug from 'debug';
 import type { MedusaAPI } from '../core/client.js';
@@ -89,15 +95,17 @@ export class MedusaProductRecommendationsProvider extends ProductRecommendations
       // Map products to recommendations
       const recommendations: ProductRecommendation[] = [];
 
-      for (const product of productsResponse.products) {
+
+
+      for (const productRes of productsResponse.products) {
+        const product = this.parseSearchResultItem(productRes);
         recommendations.push({
           recommendationIdentifier: {
-            key: `${collection.id}_${product.id}`,
+            key: `${collection.id}_${productRes.id}`,
             algorithm: 'collection',
           },
-          product: {
-            key: product.id
-          },
+          recommendationReturnType: 'productSearchResultItem',
+          product: product,
         });
       }
 
@@ -114,4 +122,43 @@ export class MedusaProductRecommendationsProvider extends ProductRecommendations
       return success([]);
     }
   }
+
+  protected parseSearchResultItem(_body: StoreProduct) {
+     const heroVariant = _body.variants?.[0];
+     const identifier = { key: _body.id };
+     const slug = _body.handle;
+     const name = heroVariant?.title || _body.title;
+     const variants = [];
+     if (heroVariant) {
+       variants.push(this.parseVariant(heroVariant, _body));
+     }
+
+     const result = {
+       identifier,
+       name,
+       slug,
+       variants,
+     } satisfies ProductSearchResultItem;
+
+     return result;
+   }
+
+   protected parseVariant(
+     variant: StoreProductVariant,
+     product: StoreProduct
+   ): ProductSearchResultItemVariant {
+     const img = ImageSchema.parse({
+       sourceUrl: product.images?.[0].url ?? '',
+       altText: product.title || undefined,
+     });
+
+     return ProductSearchResultItemVariantSchema.parse({
+       variant: ProductVariantIdentifierSchema.parse({
+         sku: variant.sku || '',
+       } satisfies ProductVariantIdentifier),
+       image: img,
+     } satisfies Partial<ProductSearchResultItemVariant>);
+   }
+
+
 }

package/providers/meilisearch/src/providers/product-recommendations.provider.ts

@@ -2,18 +2,17 @@ import {
   type Cache,
   ProductRecommendationsProvider,
   type ProductRecommendation,
-  type ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery,
   type ProductRecommendationAlgorithmSimilarProductsQuery,
-  type ProductRecommendationAlgorithmRelatedProductsQuery,
-  type ProductRecommendationAlgorithmTrendingInCategoryQuery,
   type RequestContext,
+  type ProductSearchResultItem,
+  ImageSchema,
+  type ProductSearchResultItemVariant,
+  ProductSearchResultItemVariantSchema,
 } from '@reactionary/core';
 import { MeiliSearch, type Hits, type RecordAny, type SearchParams, type SearchResponse } from 'meilisearch';
 import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
+import type { MeilisearchNativeRecord, MeilisearchNativeVariant } from '../schema/index.js';
 
-interface MeilisearchRecommendHit {
-  objectID: string;
-}
 
 /**
  * MeilisearchProductRecommendationsProvider
@@ -57,7 +56,7 @@ export class MeilisearchProductRecommendationsProvider extends ProductRecommenda
         limit: query.numberOfRecommendations,
       };
 
-      const response = await index.searchSimilarDocuments<MeilisearchRecommendHit>({
+      const response = await index.searchSimilarDocuments<MeilisearchNativeRecord>({
         id: query.sourceProduct.key,
         limit: query.numberOfRecommendations,
         embedder: this.config.useAIEmbedding,
@@ -75,15 +74,44 @@ export class MeilisearchProductRecommendationsProvider extends ProductRecommenda
   /**
    * Maps Meilisearch search results to ProductRecommendation format
    */
-  protected parseRecommendations(recommendation: SearchResponse<MeilisearchRecommendHit>, algorithm: string): ProductRecommendation[] {
+  protected parseRecommendations(recommendation: SearchResponse<MeilisearchNativeRecord>, algorithm: string): ProductRecommendation[] {
+
+    const product = this.parseSearchResultItem(recommendation.hits[0] as MeilisearchNativeRecord);
     return recommendation.hits.map((hit) => ({
       recommendationIdentifier: {
         key: hit.objectID,
         algorithm,
       },
-      product: {
-        key: hit.objectID,
-      },
+      recommendationReturnType: 'productSearchResultItem',
+      product: product
     }));
   }
+
+
+
+
+  protected parseSearchResultItem(body: MeilisearchNativeRecord) {
+    const product = {
+      identifier: { key: body.objectID },
+      name: body.name || body.objectID,
+      slug: body.slug || body.objectID,
+      variants: [...(body.variants || [])].map(variant => this.parseVariant(variant, body)),
+    } satisfies ProductSearchResultItem;
+
+    return product;
+  }
+
+  protected  parseVariant(variant: MeilisearchNativeVariant, product: MeilisearchNativeRecord): ProductSearchResultItemVariant {
+    const result = ProductSearchResultItemVariantSchema.parse({
+      variant: {
+        sku: variant.sku
+      },
+      image: ImageSchema.parse({
+        sourceUrl: variant.image,
+        altText: product.name || '',
+      })
+    } satisfies Partial<ProductSearchResultItemVariant>);
+
+    return result;
+  }
 }

package/providers/meilisearch/src/providers/product-search.provider.ts

@@ -25,19 +25,7 @@ import {
 } from '@reactionary/core';
 import { MeiliSearch, type SearchParams, type SearchResponse } from 'meilisearch';
 import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
-import type { MeilisearchProductSearchResult } from '../schema/search.schema.js';
-
-interface MeilisearchNativeVariant {
-  sku: string;
-  image: string;
-}
-
-interface MeilisearchNativeRecord {
-  objectID: string;
-  slug?: string;
-  name?: string;
-  variants: Array<MeilisearchNativeVariant>;
-}
+import type { MeilisearchNativeRecord, MeilisearchNativeVariant, MeilisearchProductSearchResult } from '../schema/search.schema.js';
 
 
 export class MeilisearchSearchProvider extends ProductSearchProvider {

package/providers/meilisearch/src/schema/search.schema.ts

@@ -12,3 +12,14 @@ export const MeilisearchProductSearchResultSchema = ProductSearchResultSchema.ex
 
 export type MeilisearchProductSearchResult = z.infer<typeof MeilisearchProductSearchResultSchema>;
 export type MeilisearchProductSearchIdentifier = z.infer<typeof MeilisearchProductSearchIdentifierSchema>;
+export interface MeilisearchNativeVariant {
+  sku: string;
+  image: string;
+}
+
+export interface MeilisearchNativeRecord {
+  objectID: string;
+  slug?: string;
+  name?: string;
+  variants: Array<MeilisearchNativeVariant>;
+}