@reactionary/source 0.0.52 → 0.2.16

package/migrations.json

@@ -1,11 +1,28 @@
 {
   "migrations": [
     {
-      "version": "21.1.0-beta.2",
-      "description": "Adds **/nx-rules.mdc and **/nx.instructions.md to .gitignore if not present",
-      "implementation": "./src/migrations/update-21-1-0/add-gitignore-entry",
-      "package": "nx",
-      "name": "21-1-0-add-ignore-entries-for-nx-rule-files"
+      "version": "22.2.0-beta.1",
+      "requires": { "vitest": ">=4.0.0" },
+      "description": "Create AI Instructions to help migrate users workspaces past breaking changes for Vitest 4.",
+      "implementation": "./src/migrations/update-22-2-0/create-ai-instructions-for-vitest-4",
+      "package": "@nx/vite",
+      "name": "update-22-2-0"
+    },
+    {
+      "version": "22.2.0-beta.2",
+      "description": "Migrate Vitest usage from @nx/vite to @nx/vitest package.",
+      "implementation": "./src/migrations/update-22-2-0/migrate-vitest-to-vitest-package",
+      "package": "@nx/vite",
+      "name": "migrate-vitest-to-vitest-package"
+    },
+    {
+      "cli": "nx",
+      "version": "22.2.0-beta.1",
+      "requires": { "next": ">=16.0.0" },
+      "description": "Create AI Instructions to help migrate users workspaces to Next.js 16.",
+      "factory": "./src/migrations/update-22-2-0/create-ai-instructions-for-next-16",
+      "package": "@nx/next",
+      "name": "update-22-2-0-create-ai-instructions-for-next-16"
     }
   ]
 }

package/nx.json

@@ -9,17 +9,12 @@
       "!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)",
       "!{projectRoot}/tsconfig.spec.json",
       "!{projectRoot}/src/test-setup.[jt]s",
-      "!{projectRoot}/jest.config.[jt]s",
-      "!{projectRoot}/test-setup.[jt]s"
+      "!{projectRoot}/test-setup.[jt]s",
+      "!{projectRoot}/vitest.config.ts"
     ],
     "sharedGlobals": ["{workspaceRoot}/.github/workflows/ci.yml"]
   },
   "targetDefaults": {
-    "@angular-devkit/build-angular:application": {
-      "cache": true,
-      "dependsOn": ["^build"],
-      "inputs": ["production", "^production"]
-    },
     "@nx/eslint:lint": {
       "cache": true,
       "inputs": [
@@ -43,28 +38,6 @@
       "inputs": ["production", "^production"]
     }
   },
-  "generators": {
-    "@nx/angular:application": {
-      "e2eTestRunner": "none",
-      "linter": "eslint",
-      "style": "scss",
-      "unitTestRunner": "jest"
-    },
-    "@nx/next": {
-      "application": {
-        "style": "scss",
-        "linter": "eslint"
-      }
-    },
-    "@nx/angular:component": {
-      "style": "scss",
-      "displayBlock": true,
-      "skipTests": true,
-      "standalone": true,
-      "changeDetection": "OnPush",
-      "viewEncapsulation": "ShadowDom"
-    }
-  },
   "release": {
     "projectsRelationship": "fixed",
     "git": {
@@ -89,34 +62,16 @@
         "targetName": "lint"
       }
     },
-    {
-      "plugin": "@nx/jest/plugin",
-      "options": {
-        "targetName": "test"
-      }
-    },
     {
       "plugin": "@nx/playwright/plugin",
       "options": {
         "targetName": "e2e"
       }
     },
-    {
-      "plugin": "@nx/next/plugin",
-      "options": {
-        "startTargetName": "start",
-        "buildTargetName": "build",
-        "devTargetName": "dev",
-        "serveStaticTargetName": "serve-static",
-        "buildDepsTargetName": "build-deps",
-        "watchDepsTargetName": "watch-deps"
-      }
-    },
     {
       "plugin": "@nx/vite/plugin",
       "options": {
         "buildTargetName": "build",
-        "testTargetName": "test",
         "serveTargetName": "serve",
         "devTargetName": "dev",
         "previewTargetName": "preview",
@@ -125,6 +80,12 @@
         "buildDepsTargetName": "build-deps",
         "watchDepsTargetName": "watch-deps"
       }
+    },
+    {
+      "plugin": "@nx/vitest",
+      "options": {
+        "testTargetName": "test"
+      }
     }
   ],
   "nxCloudId": "683eb2fef42fbc631b8c5f05"

package/package.json

@@ -1,130 +1,58 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.52",
+  "version": "0.2.16",
   "license": "MIT",
   "private": false,
   "dependencies": {
-    "@angular/common": "~19.2.0",
-    "@angular/compiler": "~19.2.0",
-    "@angular/core": "~19.2.0",
-    "@angular/forms": "~19.2.0",
-    "@angular/platform-browser": "~19.2.0",
-    "@angular/platform-browser-dynamic": "~19.2.0",
-    "@angular/router": "~19.2.0",
     "@commercetools/platform-sdk": "^8.16.0",
     "@commercetools/ts-client": "^4.2.1",
-    "@commercetools/ts-sdk-apm": "^4.0.0",
     "@faker-js/faker": "^9.8.0",
+    "@medusajs/js-sdk": "^2.13.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^2.0.1",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.203.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.203.0",
-    "@opentelemetry/instrumentation": "^0.203.0",
-    "@opentelemetry/instrumentation-express": "^0.52.0",
-    "@opentelemetry/instrumentation-http": "^0.203.0",
-    "@opentelemetry/resources": "^2.0.1",
-    "@opentelemetry/sdk-metrics": "^2.0.1",
-    "@opentelemetry/sdk-node": "^0.203.0",
     "@opentelemetry/sdk-trace-base": "^2.0.1",
     "@opentelemetry/sdk-trace-node": "^2.0.1",
-    "@opentelemetry/semantic-conventions": "^1.36.0",
-    "@trpc/client": "^11.1.2",
-    "@trpc/server": "^11.1.2",
     "@upstash/redis": "^1.34.9",
     "algoliasearch": "^5.23.4",
-    "connect-redis": "^8.1.0",
-    "cors": "^2.8.5",
     "debug": "^4.4.3",
     "dotenv": "^17.2.2",
-    "express": "^5.1.0",
-    "express-session": "^1.18.1",
-    "ioredis": "^5.6.1",
-    "next": "~15.2.4",
+    "meilisearch": "^0.55.0",
     "node-object-hash": "^3.1.1",
-    "posthog-node": "^4.18.0",
-    "react": "19.0.0",
-    "react-dom": "19.0.0",
-    "reflect-metadata": "^0.2.2",
-    "rxjs": "~7.8.0",
+    "posthog-node": "^5.24.0",
     "search-insights": "^2.17.3",
-    "superjson": "^2.2.2",
-    "vue": "^3.5.13",
-    "zod": "4.1.9",
-    "zone.js": "~0.15.0"
+    "zod": "4.1.9"
   },
   "devDependencies": {
-    "@angular-devkit/build-angular": "~19.2.0",
-    "@angular-devkit/core": "~19.2.0",
-    "@angular-devkit/schematics": "~19.2.0",
-    "@angular/cli": "~19.2.0",
-    "@angular/compiler-cli": "~19.2.0",
-    "@angular/language-service": "~19.2.0",
     "@eslint/compat": "^1.1.1",
     "@eslint/eslintrc": "^2.1.1",
     "@eslint/js": "^9.8.0",
-    "@next/eslint-plugin-next": "^15.2.4",
-    "@nx/angular": "21.1.2",
-    "@nx/devkit": "21.1.2",
-    "@nx/esbuild": "21.1.2",
-    "@nx/eslint": "21.1.2",
-    "@nx/eslint-plugin": "21.1.2",
-    "@nx/jest": "21.1.2",
-    "@nx/js": "21.1.2",
-    "@nx/next": "21.1.2",
-    "@nx/node": "21.1.2",
-    "@nx/playwright": "21.1.2",
-    "@nx/vite": "21.1.2",
-    "@nx/vue": "21.1.2",
-    "@nx/web": "21.1.2",
-    "@nx/workspace": "21.1.2",
-    "@playwright/test": "^1.36.0",
-    "@schematics/angular": "~19.2.0",
+    "@medusajs/types": "^2.11.0",
+    "@nx/devkit": "22.4.5",
+    "@nx/esbuild": "22.4.5",
+    "@nx/eslint": "22.4.5",
+    "@nx/eslint-plugin": "22.4.5",
+    "@nx/js": "22.4.5",
+    "@nx/node": "22.4.5",
+    "@nx/playwright": "22.4.5",
+    "@nx/vite": "22.4.5",
+    "@nx/vitest": "22.4.5",
+    "@nx/workspace": "22.4.5",
     "@swc-node/register": "~1.9.1",
     "@swc/cli": "~0.6.0",
     "@swc/core": "~1.5.7",
     "@swc/helpers": "~0.5.11",
     "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.12",
-    "@types/node": "18.16.9",
-    "@types/react": "19.0.0",
-    "@types/react-dom": "19.0.0",
-    "@typescript-eslint/utils": "^8.19.0",
-    "@vitejs/plugin-vue": "^5.2.3",
-    "@vitest/coverage-v8": "^3.0.5",
-    "@vitest/ui": "^3.0.0",
-    "@vue/eslint-config-prettier": "7.1.0",
-    "@vue/eslint-config-typescript": "^11.0.3",
-    "@vue/test-utils": "^2.4.6",
-    "angular-eslint": "^19.2.0",
-    "esbuild": "^0.19.2",
-    "eslint": "^9.8.0",
-    "eslint-config-next": "^15.2.4",
-    "eslint-config-prettier": "^10.0.0",
-    "eslint-plugin-import": "2.31.0",
-    "eslint-plugin-jsx-a11y": "6.10.1",
-    "eslint-plugin-playwright": "^1.6.2",
-    "eslint-plugin-react": "7.35.0",
-    "eslint-plugin-react-hooks": "5.0.0",
-    "eslint-plugin-vue": "^9.16.1",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jest-environment-node": "^29.7.0",
-    "jest-preset-angular": "~14.4.0",
-    "jiti": "2.4.2",
-    "jsdom": "~22.1.0",
-    "jsonc-eslint-parser": "^2.1.0",
-    "nx": "21.1.2",
+    "@types/node": "^24.0.0",
+    "@typescript-eslint/utils": "^8.33.1",
+    "nx": "22.4.5",
     "prettier": "^2.6.2",
-    "sass": "1.62.1",
-    "ts-jest": "^29.1.0",
     "ts-node": "10.9.1",
     "tslib": "^2.3.0",
-    "typescript": "~5.7.2",
-    "typescript-eslint": "^8.19.0",
-    "verdaccio": "^6.0.5",
-    "vite": "^6.0.0",
-    "vitest": "^3.0.0",
-    "vue-tsc": "^2.2.8"
+    "typescript": "5.9.3",
+    "typescript-eslint": "^8.33.1",
+    "vite": "7.1.9",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^4.0.9"
   },
   "nx": {
     "includedScripts": []

package/providers/algolia/README.md

@@ -1,6 +1,43 @@
-# provider-algolia
+# Algolia provider for Reactionary
+
+## Supports
+
+
+| Feature | Support | Notes |
+| -----------   | ----------- | --------- |
+| product       | Full      |          |
+| productSearch | Full     |  |
+| identity | N/A     | |
+| cart |  N/A     |  |
+| checkout | N/A     |  |
+| order | N/A    | Possibly later |
+| inventory | N/A     |  |
+| price | N/A  |  |
+| category | N/A     | Possibly later |
+| store | N/A    | Possibly later |
+
+
+## Notes
+The expected Algolia schema must contain at least these fields
+
+```json
+{
+  objectID: string;
+  slug:string;
+  name: string;
+  variants: [
+    { 
+      variantID: string; 
+      image: string;
+    }
+  ]
+}
+```
+
+You can have more, for use with facets, and additional searchable fields, but these must be in the index, and constitutes what we are expecting to get back.
+
+The `objectID` corrosponds to your productIdentifier, and `variantID` should match your SKU
 
-This library was generated with [Nx](https://nx.dev).
 
 ## Building
 

package/providers/algolia/package.json

@@ -8,5 +8,6 @@
     "algoliasearch": "^5.23.4",
     "zod": "4.1.9"
   },
-  "type": "module"
+  "type": "module",
+  "sideEffects": false
 }

package/providers/algolia/src/core/initialize.ts

@@ -1,21 +1,14 @@
-import type { Client, Cache } from "@reactionary/core";
-import { ProductSchema } from "@reactionary/core";
-import { AlgoliaProductProvider } from "../providers/product.provider.js";
-import { AlgoliaSearchProvider } from "../providers/search.provider.js";
+import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
+import { AlgoliaSearchProvider } from "../providers/product-search.provider.js";
 import type { AlgoliaCapabilities } from "../schema/capabilities.schema.js";
 import type { AlgoliaConfiguration } from "../schema/configuration.schema.js";
-import { AlgoliaSearchResultSchema } from "../schema/search.schema.js";
 
-export function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, capabilities: AlgoliaCapabilities) {
-    return (cache: Cache) => {
-        const client: Partial<Client> = {};
+export function withAlgoliaCapabilities<T extends AlgoliaCapabilities>(configuration: AlgoliaConfiguration, capabilities: T) {
+    return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
+        const client: any = {};
 
-        if (capabilities.product) {
-            client.product = new AlgoliaProductProvider(configuration, ProductSchema, cache);
-        }
-
-        if (capabilities.search) {
-            client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, cache);
+        if (capabilities.productSearch) {
+            client.productSearch = new AlgoliaSearchProvider(configuration, cache, context);
         }
 
         return client;

package/providers/algolia/src/index.ts

@@ -1,7 +1,5 @@
 export * from './core/initialize.js';
-
-export * from './providers/product.provider.js';
-export * from './providers/search.provider.js';
+export * from './providers/product-search.provider.js';
 
 export * from './schema/configuration.schema.js';
-export * from './schema/capabilities.schema.js';
+export * from './schema/capabilities.schema.js';

package/providers/algolia/src/providers/index.ts

@@ -0,0 +1 @@
+export * from './product-search.provider.js';

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

@@ -0,0 +1,241 @@
+import {
+  type Cache,
+  type FacetIdentifier,
+  FacetIdentifierSchema,
+  type FacetValueIdentifier,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductSearchProvider,
+  type ProductSearchQueryByTerm,
+  ProductSearchQueryByTermSchema,
+  type ProductSearchQueryCreateNavigationFilter,
+  type ProductSearchResult,
+  type ProductSearchResultFacet,
+  ProductSearchResultFacetSchema,
+  type ProductSearchResultFacetValue,
+  ProductSearchResultFacetValueSchema,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  ProductSearchResultItemVariantSchema,
+  ProductSearchResultSchema,
+  Reactionary,
+  type RequestContext,
+  type Result,
+  success
+} 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';
+
+interface AlgoliaNativeVariant {
+  sku: string;
+  image: string;
+}
+
+interface AlgoliaNativeRecord {
+  objectID: string;
+  slug?:string;
+  name?: string;
+  variants: Array<AlgoliaNativeVariant>;
+}
+
+
+export class AlgoliaSearchProvider extends ProductSearchProvider {
+  protected config: AlgoliaConfiguration;
+
+  constructor(config: AlgoliaConfiguration, cache: Cache, context: RequestContext) {
+    super(cache, context);
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema
+  })
+  public override async queryByTerm(
+    payload: ProductSearchQueryByTerm
+  ): Promise<Result<ProductSearchResult>> {
+    const client = algoliasearch(this.config.appId, this.config.apiKey);
+
+    const facetsThatAreNotCategory = payload.search.facets.filter(x => x.facet.key !== 'categories');
+    const categoryFacet = payload.search.facets.find(x => x.facet.key === 'categories') || payload.search.categoryFilter;
+
+    const finalFilters = [...payload.search.filters || []];
+
+
+    const finalFacetFilters = [
+      ...facetsThatAreNotCategory.map(
+        (x) => `${x.facet.key}:${x.key}`
+      ),
+    ]
+    if (categoryFacet) {
+      finalFilters.push(`categories:"${categoryFacet.key}"`);
+    }
+
+
+    const remote = await client.search<AlgoliaNativeRecord>({
+      requests: [
+        {
+          indexName: this.config.indexName,
+          query: payload.search.term,
+          page: payload.search.paginationOptions.pageNumber - 1,
+          hitsPerPage: payload.search.paginationOptions.pageSize,
+          facets: ['*'],
+          analytics: true,
+          clickAnalytics: true,
+          facetFilters: finalFacetFilters,
+          filters: (finalFilters || [])
+            .join(' AND '),
+        },
+      ],
+    });
+
+    const input = remote.results[0] as SearchResponse<AlgoliaNativeRecord>;
+    const result = this.parsePaginatedResult(input, payload) as AlgoliaProductSearchResult;
+
+    // mark selected facets as active
+    for(const selectedFacet of payload.search.facets) {
+      const facet = result.facets.find((f) => f.identifier.key === selectedFacet.facet.key);
+      if(facet) {
+          const value = facet.values.find((v) => v.identifier.key === selectedFacet.key);
+          if(value) {
+            value.active = true;
+          }
+      }
+    }
+
+    return success(result);
+  }
+
+  public override async createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>> {
+
+    const facetIdentifier = FacetIdentifierSchema.parse({
+      key: 'categories'
+    });
+    const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+      facet: facetIdentifier,
+      key: payload.categoryPath.map(c => c.name).join(' > ')
+    });
+    return success(facetValueIdentifier);
+  }
+
+
+  protected parseSingle(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 override 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;
+  }
+
+  protected parsePaginatedResult(body: SearchResponse<AlgoliaNativeRecord>, query: ProductSearchQueryByTerm) {
+    const items = body.hits.map((hit) => this.parseSingle(hit));
+    let facets: ProductSearchResultFacet[] = [];
+    for (const id in body.facets) {
+      const f = body.facets[id];
+      const facetId = FacetIdentifierSchema.parse({
+        key: id
+      })
+      const facet = this.parseFacet(facetId, f);
+      facets.push(facet);
+    }
+
+
+    // we do something to convert the hierachy.lvl.n facet values into something more usable
+    const selectedCategoryFacet = query.search.facets.find(x => x.facet.key === 'categories') || query.search.categoryFilter;
+    let subCategoryFacet;
+    if(selectedCategoryFacet) {
+      const valueDepth = selectedCategoryFacet.key.split(' > ').length;
+      // ok, so input defined a facet value from level X, we return hierarchy.lvl.(X+1) as subcategories.
+      // hierarchy counts from 0, so length is already pointing to 'lvl.(X+1)'
+      subCategoryFacet = facets.find(f => f.identifier.key === `hierarchy.lvl${valueDepth}`);
+    } else {
+      // and remap lvl0 to 'categories'
+      subCategoryFacet = facets.find(f => f.identifier.key === 'hierarchy.lvl0');
+    }
+
+    if(subCategoryFacet) {
+      // remap to 'categories' facet
+      subCategoryFacet.identifier = FacetIdentifierSchema.parse({
+        key: 'categories'
+      });
+      subCategoryFacet.name = 'Categories';
+      for(const v of subCategoryFacet.values) {
+        const pathParts = v.identifier.key.split(' > ');
+        v.identifier.facet = subCategoryFacet.identifier;
+        v.name = pathParts[pathParts.length -1];
+      }
+    }
+
+    // remove other hierarchy facets
+    facets = facets.filter(f => !f.identifier.key.startsWith('hierarchy.lvl'));
+
+
+
+    const result = {
+      identifier: {
+        term: query.search.term,
+        facets: query.search.facets,
+        filters: query.search.filters,
+        paginationOptions: query.search.paginationOptions,
+
+      },
+      pageNumber: (body.page || 0) + 1,
+      pageSize: body.hitsPerPage || 0,
+      totalCount: body.nbHits || 0,
+      totalPages: body.nbPages || 0,
+      items: items,
+      facets,
+    } satisfies ProductSearchResult;
+
+    return result;
+  }
+
+  protected parseFacet(facetIdentifier: FacetIdentifier,  facetValues: Record<string, number>) : ProductSearchResultFacet {
+    const result: ProductSearchResultFacet = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facetIdentifier.key,
+      values: []
+    });
+
+    for (const vid in facetValues) {
+      const fv = facetValues[vid];
+
+      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+        facet: facetIdentifier,
+        key: vid
+      } satisfies Partial<FacetValueIdentifier>);
+
+      result.values.push(this.parseFacetValue(facetValueIdentifier, vid, fv));
+    }
+    return result;
+  }
+
+  protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier,  label: string, count: number) : ProductSearchResultFacetValue {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count: count,
+      active: false,
+    } satisfies Partial<ProductSearchResultFacetValue>);
+  }
+
+
+}

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

@@ -2,9 +2,8 @@ import { CapabilitiesSchema } from "@reactionary/core";
 import type { z } from 'zod';
 
 export const AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
-    product: true,
-    search: true,
+    productSearch: true,
     analytics: true
 }).partial();
 
-export type AlgoliaCapabilities = z.infer<typeof AlgoliaCapabilitiesSchema>;
+export type AlgoliaCapabilities = z.infer<typeof AlgoliaCapabilitiesSchema>;

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

@@ -0,0 +1,3 @@
+export * from './capabilities.schema.js';
+export * from './configuration.schema.js';
+export * from './search.schema.js';

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

@@ -1,14 +1,14 @@
-import { SearchIdentifierSchema, SearchResultSchema } from '@reactionary/core';
+import { ProductSearchIdentifierSchema, ProductSearchResultSchema } from '@reactionary/core';
 import { z } from 'zod';
 
-export const AlgoliaSearchIdentifierSchema = SearchIdentifierSchema.extend({
-   key: z.string().default(''),
-   index: z.string().default('')
+export const AlgoliaProductSearchIdentifierSchema = ProductSearchIdentifierSchema.extend({
+   key: z.string(),
+   index: z.string(),
 });
 
-export const AlgoliaSearchResultSchema = SearchResultSchema.extend({
-    identifier: AlgoliaSearchIdentifierSchema.default(() => AlgoliaSearchIdentifierSchema.parse({}))
+export const AlgoliaProductSearchResultSchema = ProductSearchResultSchema.extend({
+    identifier: AlgoliaProductSearchIdentifierSchema.default(() => AlgoliaProductSearchIdentifierSchema.parse({}))
 });
 
-export type AlgoliaSearchResult = z.infer<typeof AlgoliaSearchResultSchema>;
-export type AlgoliaSearchIdentifier = z.infer<typeof AlgoliaSearchIdentifierSchema>;
+export type AlgoliaProductSearchResult = z.infer<typeof AlgoliaProductSearchResultSchema>;
+export type AlgoliaProductSearchIdentifier = z.infer<typeof AlgoliaProductSearchIdentifierSchema>;