@reactionary/source 0.0.27

package/nx.json

@@ -0,0 +1,130 @@
+{
+  "$schema": "./node_modules/nx/schemas/nx-schema.json",
+  "namedInputs": {
+    "default": ["{projectRoot}/**/*", "sharedGlobals"],
+    "production": [
+      "default",
+      "!{projectRoot}/.eslintrc.json",
+      "!{projectRoot}/eslint.config.mjs",
+      "!{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"
+    ],
+    "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": [
+        "default",
+        "{workspaceRoot}/.eslintrc.json",
+        "{workspaceRoot}/.eslintignore",
+        "{workspaceRoot}/eslint.config.mjs"
+      ]
+    },
+    "@nx/esbuild:esbuild": {
+      "cache": true,
+      "dependsOn": ["^build"],
+      "inputs": ["production", "^production"]
+    },
+    "e2e-ci--**/*": {
+      "dependsOn": ["^build"]
+    },
+    "@nx/js:tsc": {
+      "cache": true,
+      "dependsOn": ["^build"],
+      "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": {
+    "git": {
+      "commit": false,
+      "stageChanges": false,
+      "tag": true
+    },
+    "version": {
+      "preVersionCommand": "pnpm nx run-many -t build"
+    },
+    "changelog": {
+      "workspaceChangelog": {
+        "createRelease": "github",
+        "file": false
+      }
+    }
+  },
+  "plugins": [
+    {
+      "plugin": "@nx/eslint/plugin",
+      "options": {
+        "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",
+        "serveStaticTargetName": "serve-static",
+        "typecheckTargetName": "typecheck",
+        "buildDepsTargetName": "build-deps",
+        "watchDepsTargetName": "watch-deps"
+      }
+    }
+  ],
+  "nxCloudId": "683eb2fef42fbc631b8c5f05"
+}

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@reactionary/source",
+  "version": "0.0.27",
+  "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.8.0",
+    "@commercetools/ts-client": "^3.2.2",
+    "@faker-js/faker": "^9.8.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",
+    "express": "^5.1.0",
+    "express-session": "^1.18.1",
+    "ioredis": "^5.6.1",
+    "next": "~15.2.4",
+    "posthog-node": "^4.18.0",
+    "react": "19.0.0",
+    "react-dom": "19.0.0",
+    "rxjs": "~7.8.0",
+    "search-insights": "^2.17.3",
+    "superjson": "^2.2.2",
+    "vue": "^3.5.13",
+    "zod": "4.0.0-beta.20250430T185432",
+    "zone.js": "~0.15.0"
+  },
+  "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",
+    "@swc-node/register": "~1.9.1",
+    "@swc/cli": "~0.6.0",
+    "@swc/core": "~1.5.7",
+    "@swc/helpers": "~0.5.11",
+    "@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/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",
+    "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"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "packageManager": "pnpm@8.15.9+sha512.499434c9d8fdd1a2794ebf4552b3b25c0a633abcee5bb15e7b5de90f32f47b513aca98cd5cfd001c31f0db454bc3804edccd578501e4ca293a6816166bbd9f81",
+  "scripts": {}
+}

package/project.json

@@ -0,0 +1,14 @@
+{
+  "name": "@reactionary/source",
+  "$schema": "node_modules/nx/schemas/project-schema.json",
+  "targets": {
+    "local-registry": {
+      "executor": "@nx/js:verdaccio",
+      "options": {
+        "port": 4873,
+        "config": ".verdaccio/config.yml",
+        "storage": "tmp/local-registry/storage"
+      }
+    }
+  }
+}

package/providers/algolia/README.md

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

package/providers/algolia/eslint.config.mjs

@@ -0,0 +1,22 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/providers/algolia/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'provider-algolia',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/providers/algolia',
+};

package/providers/algolia/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@reactionary/provider-algolia",
+  "version": "0.0.1",
+  "dependencies": {
+    "@reactionary/core": "0.0.1",
+    "algoliasearch": "^5.23.4",
+    "zod": "4.0.0-beta.20250430T185432"
+  }
+}

package/providers/algolia/project.json

@@ -0,0 +1,33 @@
+{
+  "name": "provider-algolia",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "providers/algolia/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/algolia",
+        "main": "providers/algolia/src/index.ts",
+        "tsConfig": "providers/algolia/tsconfig.lib.json",
+        "assets": ["providers/algolia/*.md"],
+        "format": ["esm"]
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Client, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema } from "@reactionary/core";
+import { AlgoliaProductProvider } from "../providers/product.provider";
+import { AlgoliaSearchProvider } from "../providers/search.provider";
+import { AlgoliaCapabilities } from "../schema/capabilities.schema";
+import { AlgoliaConfiguration } from "../schema/configuration.schema";
+import { AlgoliaSearchResultSchema } from "../schema/search.schema";
+
+export function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, capabilities: AlgoliaCapabilities) {
+    const client: Partial<Client> = {};
+
+    if (capabilities.product) {
+        client.product = new AlgoliaProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
+    }
+
+    if (capabilities.search) {
+        client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, SearchQuerySchema, SearchMutationSchema);
+    }
+
+    return client;
+}

package/providers/algolia/src/index.ts

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

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

@@ -0,0 +1,25 @@
+import { BaseMutation, Product, ProductMutation, ProductProvider, ProductQuery, Session } from '@reactionary/core';
+import { z } from 'zod';
+import { AlgoliaConfiguration } from '../schema/configuration.schema';
+
+export class AlgoliaProductProvider<
+  T extends Product = Product,
+  Q extends ProductQuery = ProductQuery,
+  M extends ProductMutation = ProductMutation
+> extends ProductProvider<T, Q, M> {
+  protected config: AlgoliaConfiguration;
+
+  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
+    super(schema, querySchema, mutationSchema);
+
+    this.config = config;
+  }
+
+  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
+    return [];
+  }
+
+  protected override process(mutation: BaseMutation[], session: Session): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+}

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

@@ -0,0 +1,125 @@
+import {
+  SearchIdentifier,
+  SearchMutation,
+  SearchProvider,
+  SearchQuery,
+  SearchResult,
+  SearchResultFacetSchema,
+  SearchResultFacetValueSchema,
+  Session,
+} from '@reactionary/core';
+import { algoliasearch } from 'algoliasearch';
+import { z } from 'zod';
+import { AlgoliaConfiguration } from '../schema/configuration.schema';
+
+export class AlgoliaSearchProvider<
+  T extends SearchResult = SearchResult,
+  Q extends SearchQuery = SearchQuery,
+  M extends SearchMutation = SearchMutation
+> extends SearchProvider<T, Q, M> {
+  protected config: AlgoliaConfiguration;
+
+  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
+    super(schema, querySchema, mutationSchema);
+
+    this.config = config;
+  }
+
+  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
+    const results = [];
+
+    for (const query of queries) {
+      const result = await this.get(query.search);
+
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  protected override process(mutations: M[], session: Session): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+
+  protected async get(identifier: SearchIdentifier): Promise<T> {
+    const client = algoliasearch(this.config.appId, this.config.apiKey);
+    const remote = await client.search<unknown>({
+      requests: [
+        {
+          indexName: this.config.indexName,
+          query: identifier.term,
+          page: identifier.page,
+          hitsPerPage: identifier.pageSize,
+          facets: ['*'],
+          analytics: true,
+          clickAnalytics: true,
+          facetFilters: identifier.facets.map(
+            (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
+          ),
+        },
+      ],
+    });
+
+    const parsed = this.parse(remote, identifier);
+
+    return parsed;
+  }
+
+  protected parse(remote: any, query: SearchIdentifier): T {
+    const result = this.newModel();
+
+    const remoteProducts = remote.results[0];
+
+    for (const id in remoteProducts.facets) {
+      const f = remoteProducts.facets[id];
+
+      const facet = SearchResultFacetSchema.parse({});
+      facet.identifier.key = id;
+      facet.name = id;
+
+      for (const vid in f) {
+        const fv = f[vid];
+
+        const facetValue = SearchResultFacetValueSchema.parse({});
+        facetValue.count = fv;
+        facetValue.name = vid;
+        facetValue.identifier.key = vid;
+        facetValue.identifier.facet = facet.identifier;
+
+        if (
+          query.facets.find(
+            (x) =>
+              x.facet.key == facetValue.identifier.facet.key &&
+              x.key == facetValue.identifier.key
+          )
+        ) {
+          facetValue.active = true;
+        }
+
+        facet.values.push(facetValue);
+      }
+
+      result.facets.push(facet);
+    }
+
+    for (const p of remoteProducts.hits) {
+      result.products.push({
+        identifier: {
+          key: p.objectID,
+        },
+        slug: p.slug,
+        name: p.name,
+        image: p.image,
+      });
+    }
+
+    result.identifier = {
+      ...query,
+      index: remoteProducts.index,
+      key: remoteProducts.queryID
+    };
+    result.pages = remoteProducts.nbPages;
+
+    return result;
+  }
+}

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

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

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const AlgoliaConfigurationSchema = z.looseInterface({
+    appId: z.string(),
+    apiKey: z.string(),
+    indexName: z.string()
+});
+
+export type AlgoliaConfiguration = z.infer<typeof AlgoliaConfigurationSchema>;

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

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

package/providers/algolia/src/test/product.provider.spec.ts

@@ -0,0 +1,18 @@
+import { ProductSchema } from '@reactionary/core';
+import { AlgoliaProductProvider } from '../providers/product.provider';
+
+describe('Algolia Product Provider', () => {
+  it('should be able to get a product by id', async () => {
+    const provider = new AlgoliaProductProvider({
+        apiKey: process.env['ALGOLIA_API_KEY'] || '',
+        appId: process.env['ALGOLIA_APP_ID'] || '',
+        indexName: process.env['ALGOLIA_INDEX'] || ''
+    }, ProductSchema);
+
+    const result = await provider.get({ id: '4d28f98d-c446-446e-b59a-d9f718e5b98a'});
+
+    expect(result.identifier.key).toBe('4d28f98d-c446-446e-b59a-d9f718e5b98a');
+    expect(result.name).toBe('Sunnai Glass Bowl');
+    expect(result.image).toBe('https://res.cloudinary.com/dfke2ip5c/image/upload/c_thumb,w_200,g_face/v1744117881/6d189e9017e385a6a465b9099227ccae.jpeg');
+  });
+});

package/providers/algolia/src/test/search.provider.spec.ts

@@ -0,0 +1,82 @@
+import { SearchResultSchema } from '@reactionary/core';
+import { AlgoliaSearchProvider } from '../providers/search.provider';
+
+describe('Algolia Search Provider', () => {
+  const provider = new AlgoliaSearchProvider({
+    apiKey: process.env['ALGOLIA_API_KEY'] || '',
+    appId: process.env['ALGOLIA_APP_ID'] || '',
+    indexName: process.env['ALGOLIA_INDEX'] || '',
+  }, SearchResultSchema);
+
+  it('should be able to get a result by term', async () => {
+    const result = await provider.get({
+      term: 'glass',
+      page: 0,
+      pageSize: 20,
+      facets: [],
+    });
+
+    expect(result.products.length).toBeGreaterThan(0);
+    expect(result.facets.length).toBe(2);
+    expect(result.facets[0].values.length).toBeGreaterThan(0);
+    expect(result.facets[1].values.length).toBeGreaterThan(0);
+  });
+
+  it('should be able to paginate', async () => {
+    const firstPage = await provider.get({
+      term: 'glass',
+      page: 0,
+      pageSize: 20,
+      facets: [],
+    });
+    const secondPage = await provider.get({
+      term: 'glass',
+      page: 1,
+      pageSize: 20,
+      facets: [],
+    });
+
+    expect(firstPage.identifier.page).toBe(0);
+    expect(secondPage.identifier.page).toBe(1);
+    expect(firstPage.products[0].identifier.key).not.toEqual(
+      secondPage.products[0].identifier.key
+    );
+  });
+
+  it('should be able to change page size', async () => {
+    const smallPage = await provider.get({
+      term: 'glass',
+      page: 0,
+      pageSize: 2,
+      facets: [],
+    });
+    const largePage = await provider.get({
+      term: 'glass',
+      page: 0,
+      pageSize: 30,
+      facets: [],
+    });
+
+    expect(smallPage.products.length).toBe(2);
+    expect(smallPage.identifier.pageSize).toBe(2);
+    expect(largePage.products.length).toBe(30);
+    expect(largePage.identifier.pageSize).toBe(30);
+  });
+
+  it('should be able to apply facets', async () => {
+    const initial = await provider.get({
+      term: 'glass',
+      page: 0,
+      pageSize: 2,
+      facets: [],
+    });
+    const filtered = await provider.get({
+      term: 'glass',
+      page: 0,
+      pageSize: 2,
+      facets: [initial.facets[0].values[0].identifier],
+    });
+
+    expect(initial.pages).toBeGreaterThan(filtered.pages);
+  });
+});