@reactionary/source 0.0.51 → 0.2.15

package/providers/meilisearch/project.json

@@ -0,0 +1,34 @@
+{
+  "name": "provider-meilisearch",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "providers/meilisearch/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk",
+      "preserveLocalDependencyProtocols": false,
+      "manifestRootsToUpdate": ["dist/{projectRoot}"]
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/providers/meilisearch",
+        "main": "providers/meilisearch/src/index.ts",
+        "tsConfig": "providers/meilisearch/tsconfig.lib.json",
+        "assets": ["providers/meilisearch/*.md"],
+        "format": ["esm"],
+        "bundle": false
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
+import { MeilisearchSearchProvider } from "../providers/product-search.provider.js";
+import type { MeilisearchCapabilities } from "../schema/capabilities.schema.js";
+import type { MeilisearchConfiguration } from "../schema/configuration.schema.js";
+
+export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(configuration: MeilisearchConfiguration, capabilities: T) {
+    return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
+        const client: any = {};
+
+        if (capabilities.productSearch) {
+            client.productSearch = new MeilisearchSearchProvider(configuration, cache, context);
+        }
+
+        return client;
+    };
+}

package/providers/meilisearch/src/index.ts

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

package/providers/meilisearch/src/providers/index.ts

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

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

@@ -0,0 +1,251 @@
+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 { 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>;
+}
+
+
+export class MeilisearchSearchProvider extends ProductSearchProvider {
+  protected config: MeilisearchConfiguration;
+
+  constructor(config: MeilisearchConfiguration, cache: Cache, context: RequestContext) {
+    super(cache, context);
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+  public override async queryByTerm(
+    payload: ProductSearchQueryByTerm
+  ): Promise<Result<ProductSearchResult>> {
+    const client = new MeiliSearch({
+      host: this.config.apiUrl,
+      apiKey: this.config.apiKey,
+    });
+
+    const index = client.index(this.config.indexName);
+
+    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: string[] = [...payload.search.filters || []];
+
+    const finalFacetFilters: string[] = [
+      ...facetsThatAreNotCategory.map(
+        (x) => `${x.facet.key}="${x.key}"`
+      ),
+    ];
+
+    if (categoryFacet) {
+      finalFilters.push(`categories = "${categoryFacet.key}"`);
+    }
+
+    // Combine all filters
+    let filterString: string | undefined;
+    if (finalFilters.length > 0 || finalFacetFilters.length > 0) {
+      const allFilters = [...finalFilters, ...finalFacetFilters];
+      filterString = allFilters.join(' AND ');
+    }
+
+    const searchOptions: SearchParams = {
+      offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize,
+      limit: payload.search.paginationOptions.pageSize,
+      facets: ['*'],
+      filter: filterString,
+    };
+
+    if (this.config.useAIEmbedding) {
+      searchOptions.hybrid = {
+        embedder: this.config.useAIEmbedding
+      };
+    }
+
+    const remote = await index.search<MeilisearchNativeRecord>(payload.search.term, searchOptions);
+
+    const result = this.parsePaginatedResult(remote, payload) as MeilisearchProductSearchResult;
+
+    // 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: 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 override 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;
+  }
+
+  protected parsePaginatedResult(body: SearchResponse<MeilisearchNativeRecord>, query: ProductSearchQueryByTerm) {
+    const items = body.hits.map((hit) => this.parseSingle(hit));
+    let facets: ProductSearchResultFacet[] = [];
+
+    if (body.facetDistribution) {
+      for (const id in body.facetDistribution) {
+        const f = body.facetDistribution[id];
+        const facetId = FacetIdentifierSchema.parse({
+          key: id
+        });
+        const facet = this.parseFacet(facetId, f);
+        if (facet.values.length > 0) {
+        facets.push(facet);
+        }
+      }
+    }
+
+    // Handle category hierarchy similar to Algolia
+    const selectedCategoryFacet = query.search.facets.find(x => x.facet.key === 'categories') || query.search.categoryFilter;
+    let subCategoryFacet;
+    if (selectedCategoryFacet) {
+      const valueDepth = selectedCategoryFacet.key.split(' > ').length;
+      subCategoryFacet = facets.find(f => f.identifier.key === `hierarchy.lvl${valueDepth}`);
+    } else {
+      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 totalPages = Math.ceil((body.estimatedTotalHits || 0) / query.search.paginationOptions.pageSize);
+
+    const result = {
+      identifier: {
+        term: query.search.term,
+        facets: query.search.facets,
+        filters: query.search.filters,
+        paginationOptions: query.search.paginationOptions,
+      },
+      pageNumber: query.search.paginationOptions.pageNumber,
+      pageSize: query.search.paginationOptions.pageSize,
+      totalCount: body.estimatedTotalHits || 0,
+      totalPages: totalPages,
+      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.replace(/_/g, ' '),
+      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/meilisearch/src/schema/capabilities.schema.ts

@@ -0,0 +1,9 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import type { z } from 'zod';
+
+export const MeilisearchCapabilitiesSchema = CapabilitiesSchema.pick({
+    productSearch: true,
+    analytics: true
+}).partial();
+
+export type MeilisearchCapabilities = z.infer<typeof MeilisearchCapabilitiesSchema>;

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const MeilisearchConfigurationSchema = z.looseObject({
+    apiUrl: z.string(),
+    apiKey: z.string(),
+    indexName: z.string(),
+    useAIEmbedding: z.string().optional()
+});
+
+export type MeilisearchConfiguration = z.infer<typeof MeilisearchConfigurationSchema>;

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

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

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

@@ -0,0 +1,14 @@
+import { ProductSearchIdentifierSchema, ProductSearchResultSchema } from '@reactionary/core';
+import { z } from 'zod';
+
+export const MeilisearchProductSearchIdentifierSchema = ProductSearchIdentifierSchema.extend({
+   key: z.string(),
+   index: z.string(),
+});
+
+export const MeilisearchProductSearchResultSchema = ProductSearchResultSchema.extend({
+    identifier: MeilisearchProductSearchIdentifierSchema.default(() => MeilisearchProductSearchIdentifierSchema.parse({}))
+});
+
+export type MeilisearchProductSearchResult = z.infer<typeof MeilisearchProductSearchResultSchema>;
+export type MeilisearchProductSearchIdentifier = z.infer<typeof MeilisearchProductSearchIdentifierSchema>;

package/{otel → providers/meilisearch}/tsconfig.json

@@ -1,7 +1,8 @@
 {
-  "extends": "../tsconfig.base.json",
+  "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "commonjs",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "importHelpers": true,

package/{trpc → providers/meilisearch}/tsconfig.lib.json

@@ -1,10 +1,10 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "outDir": "../dist/out-tsc",
+    "outDir": "../../dist/out-tsc",
     "declaration": true,
     "types": ["node"]
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+  "exclude": ["src/**/*.spec.ts", "vitest.config.ts"]
 }

package/providers/meilisearch/tsconfig.spec.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
+}

package/providers/meilisearch/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig, defineProject } from 'vitest/config';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { resolve } from 'path';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+
+export default defineProject({
+  plugins: [nxViteTsPaths()],
+  test: {
+    root: resolve(__dirname),
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.spec.ts'],
+  },
+});

package/providers/posthog/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@reactionary/provider-posthog",
   "version": "0.0.1",
-  "type": "commonjs",
-  "main": "./index.cjs",
-  "types": "./index.d.ts",
+  "main": "index.js",
+  "types": "src/index.d.ts",
   "dependencies": {
     "@reactionary/core": "0.0.1",
     "zod": "4.1.9"
-  }
+  },
+  "type": "module",
+  "sideEffects": false
 }

package/providers/posthog/project.json

@@ -20,8 +20,8 @@
         "main": "providers/posthog/src/index.ts",
         "tsConfig": "providers/posthog/tsconfig.lib.json",
         "assets": ["providers/posthog/*.md"],
-        "format": ["cjs"],
-        "generatePackageJson": true
+        "format": ["esm"],
+        "bundle": false
       }
     },
     "nx-release-publish": {

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

@@ -1,6 +1,6 @@
 import type { Client, Cache } from "@reactionary/core";
-import type { PosthogConfiguration } from "../schema/configuration.schema";
-import type { PosthogCapabilities } from "../schema/capabilities.schema";
+import type { PosthogConfiguration } from "../schema/configuration.schema.js";
+import type { PosthogCapabilities } from "../schema/capabilities.schema.js";
 
 export function withPosthogCapabilities(_configuration: PosthogConfiguration, _capabilities: PosthogCapabilities) {
     return (_cache: Cache) => {

package/providers/posthog/src/index.ts

@@ -1,4 +1,4 @@
-export * from './core/initialize';
+export * from './core/initialize.js';
 
-export * from './schema/capabilities.schema';
-export * from './schema/configuration.schema';
+export * from './schema/capabilities.schema.js';
+export * from './schema/configuration.schema.js';

package/providers/posthog/tsconfig.json

@@ -1,7 +1,8 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "commonjs",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "importHelpers": true,

package/tsconfig.base.json

@@ -17,15 +17,19 @@
     "paths": {
       "@reactionary/core": ["core/src/index.ts"],
       "@reactionary/examples-node": ["examples/node/src/index.ts"],
+      "@reactionary/provider-medusa": ["providers/medusa/src/index.ts"],
       "@reactionary/otel": ["otel/src/index.ts"],
       "@reactionary/provider-algolia": ["providers/algolia/src/index.ts"],
+      "@reactionary/provider-meilisearch": [
+        "providers/meilisearch/src/index.ts"
+      ],
       "@reactionary/provider-commercetools": [
         "providers/commercetools/src/index.ts"
       ],
       "@reactionary/provider-fake": ["providers/fake/src/index.ts"],
-      "@reactionary/provider-posthog": ["providers/posthog/src/index.ts"],
-      "@reactionary/trpc": ["trpc/src/index.ts"]
-    }
+      "@reactionary/provider-posthog": ["providers/posthog/src/index.ts"]
+    },
+    "verbatimModuleSyntax": true
   },
   "exclude": ["node_modules", "tmp"]
 }

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { resolve } from 'path'
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    projects: ['providers/*', 'examples/*', 'core'],
+    reporters: ['default', 'verbose', 'github-actions'],
+
+  },
+})

package/core/src/providers/search.provider.ts

@@ -1,18 +0,0 @@
-import type { SearchResult } from '../schemas/models/search.model';
-import type { SearchQueryByTerm } from '../schemas/queries/search.query';
-import type { RequestContext } from '../schemas/session.schema';
-import { BaseProvider } from './base.provider';
-
-export abstract class SearchProvider<
-  T extends SearchResult = SearchResult
-> extends BaseProvider<T> {
-  public abstract queryByTerm(payload: SearchQueryByTerm, reqCtx: RequestContext): Promise<SearchResult>;
-
-
-  protected override getResourceName(): string {
-    return 'product-search';
-  }
-
-}
-
-

package/core/src/schemas/models/search.model.ts

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSchema, SearchIdentifierSchema } from './identifiers.model';
-import { BaseModelSchema, createPaginatedResponseSchema } from './base.model';
-import { create } from 'domain';
-
-export const SearchResultProductSchema = z.looseObject({
-    identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
-    name: z.string().default(''),
-    image: z.string().url().default('https://placehold.co/400'),
-    slug: z.string().default('')
-});
-
-export const SearchResultFacetValueSchema = z.looseObject({
-    identifier: FacetValueIdentifierSchema.default(() => FacetValueIdentifierSchema.parse({})),
-    name: z.string().default(''),
-    count: z.number().default(0),
-    active: z.boolean().default(false)
-});
-
-export const SearchResultFacetSchema = z.looseObject({
-    identifier: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
-    name: z.string().default(''),
-    values: z.array(SearchResultFacetValueSchema).default(() => [])
-});
-
-export const SearchResultSchema = BaseModelSchema.extend({
-    identifier: SearchIdentifierSchema.default(() => SearchIdentifierSchema.parse({})),
-    products: z.array(SearchResultProductSchema).default(() => []),
-    pages: z.number().default(0),
-    facets: z.array(SearchResultFacetSchema).default(() => [])
-});
-
-
-export type SearchResultProduct = z.infer<typeof SearchResultProductSchema>;
-export type SearchResult = z.infer<typeof SearchResultSchema>;
-export type SearchResultFacet = z.infer<typeof SearchResultFacetSchema>;
-export type SearchResultFacetValue = z.infer<typeof SearchResultFacetValueSchema>;

package/core/src/schemas/queries/search.query.ts

@@ -1,9 +0,0 @@
-import type { z } from 'zod';
-import { BaseQuerySchema } from './base.query';
-import { SearchIdentifierSchema } from '../models/identifiers.model';
-
-export const SearchQueryByTermSchema = BaseQuerySchema.extend({
-    search: SearchIdentifierSchema.required()
-});
-
-export type SearchQueryByTerm = z.infer<typeof SearchQueryByTermSchema>;

package/examples/next/.swcrc

@@ -1,30 +0,0 @@
-{
-  "jsc": {
-    "target": "es2017",
-    "parser": {
-      "syntax": "typescript",
-      "decorators": true,
-      "dynamicImport": true
-    },
-    "transform": {
-      "decoratorMetadata": true,
-      "legacyDecorator": true
-    },
-    "keepClassNames": true,
-    "externalHelpers": true,
-    "loose": true
-  },
-  "module": {
-    "type": "commonjs"
-  },
-  "sourceMaps": true,
-  "exclude": [
-    "jest.config.ts",
-    ".*\\.spec.tsx?$",
-    ".*\\.test.tsx?$",
-    "./src/jest-setup.ts$",
-    "./**/jest-setup.ts$",
-    ".*.js$",
-    ".*.d.ts$"
-  ]
-}

package/examples/next/eslint.config.mjs

@@ -1,21 +0,0 @@
-import { FlatCompat } from '@eslint/eslintrc';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import js from '@eslint/js';
-import { fixupConfigRules } from '@eslint/compat';
-import nx from '@nx/eslint-plugin';
-import baseConfig from '../../eslint.config.mjs';
-const compat = new FlatCompat({
-  baseDirectory: dirname(fileURLToPath(import.meta.url)),
-  recommendedConfig: js.configs.recommended,
-});
-
-export default [
-  ...fixupConfigRules(compat.extends('next')),
-  ...fixupConfigRules(compat.extends('next/core-web-vitals')),
-  ...baseConfig,
-  ...nx.configs['flat/react-typescript'],
-  {
-    ignores: ['.next/**/*'],
-  },
-];

package/examples/next/index.d.ts

@@ -1,6 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-declare module '*.svg' {
-  const content: any;
-  export const ReactComponent: any;
-  export default content;
-}

package/examples/next/next-env.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="next" />
-/// <reference types="next/image-types/global" />
-
-// NOTE: This file should not be edited
-// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/examples/next/next.config.js

@@ -1,20 +0,0 @@
-//@ts-check
-
- 
-const { composePlugins, withNx } = require('@nx/next');
-
-/**
- * @type {import('@nx/next/plugins/with-nx').WithNxOptions}
- **/
-const nextConfig = {
-  // Use this to set Nx-specific options
-  // See: https://nx.dev/recipes/next/next-config-setup
-  nx: {},
-};
-
-const plugins = [
-  // Add more Next.js plugins to this list if needed.
-  withNx,
-];
-
-module.exports = composePlugins(...plugins)(nextConfig);