@reactionary/source 0.0.27

package/providers/commercetools/src/providers/identity.provider.ts

@@ -0,0 +1,130 @@
+import {
+  Identity,
+  IdentityMutation,
+  IdentityMutationLogin,
+  IdentityProvider,
+  IdentityQuery,
+  Session,
+} from '@reactionary/core';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import z from 'zod';
+import { CommercetoolsClient } from '../core/client';
+
+export class CommercetoolsIdentityProvider<
+  T extends Identity = Identity,
+  Q extends IdentityQuery = IdentityQuery,
+  M extends IdentityMutation = IdentityMutation
+> extends IdentityProvider<T, Q, M> {
+  protected config: CommercetoolsConfiguration;
+
+  constructor(
+    config: CommercetoolsConfiguration,
+    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(session);
+
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  protected override async process(
+    mutations: M[],
+    session: Session
+  ): Promise<T> {
+    let result = this.newModel();
+
+    for (const mutation of mutations) {
+      switch (mutation.mutation) {
+        case 'login':
+          result = await this.login(mutation, session);
+          break;
+        case 'logout':
+          result = await this.logout(session);
+          break;
+      }
+    }
+
+    return result;
+  }
+
+  protected async get(session: Session): Promise<T> {
+    const client = new CommercetoolsClient(this.config);
+    const base = this.newModel();
+
+    if (session.identity.token) {
+      const remote = await client.introspect(session.identity.token);
+
+      if (remote.active) {
+        const current = this.schema.safeParse(session.identity);
+
+        if (current.success) {
+          return current.data;
+        }
+      }
+    }
+
+    session.identity = base;
+
+    return base;
+  }
+
+  protected async login(
+    payload: IdentityMutationLogin,
+    session: Session
+  ): Promise<T> {
+    const client = new CommercetoolsClient(this.config);
+    const remote = await client.login(payload.username, payload.password);
+    const base = this.newModel();
+
+    if (remote && remote.access_token) {
+      base.issued = new Date();
+      base.expiry = new Date();
+      base.expiry.setSeconds(base.expiry.getSeconds() + remote.expires_in);
+      base.id = this.extractCustomerIdFromScopes(remote.scope);
+      base.token = remote.access_token;
+      base.type = 'Registered';
+    }
+
+    // TODO: error handling
+
+    session.identity = base;
+
+    return base;
+  }
+
+  protected async logout(session: Session): Promise<T> {
+    const client = new CommercetoolsClient(this.config);
+    const base = this.newModel();
+
+    if (session.identity.token) {
+      const remote = await client.logout(session.identity.token);
+
+      // TODO: error handling
+    }
+
+    session.identity = base;
+
+    return base;
+  }
+
+  protected extractCustomerIdFromScopes(scopes: string) {
+    const scopeList = scopes.split(' ');
+    const customerScope = scopeList.find((x) => x.startsWith('customer_id'));
+    const id = customerScope?.split(':')[1];
+
+    return id || '';
+  }
+}

package/providers/commercetools/src/providers/inventory.provider.ts

@@ -0,0 +1,82 @@
+import {
+  BaseCachingStrategy,
+  Inventory,
+  InventoryProvider,
+  InventoryQuery,
+  RedisCache,
+  Session,
+} from '@reactionary/core';
+import z from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { CommercetoolsClient } from '../core/client';
+import { InventoryMutation } from 'core/src/schemas/mutations/inventory.mutation';
+
+export class CommercetoolsInventoryProvider<
+  T extends Inventory = Inventory,
+  Q extends InventoryQuery = InventoryQuery,
+  M extends InventoryMutation = InventoryMutation
+> extends InventoryProvider<T, Q, M> {
+  protected config: CommercetoolsConfiguration;
+  protected cache = new RedisCache(new BaseCachingStrategy());
+
+  constructor(
+    config: CommercetoolsConfiguration,
+    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) {
+      let result = await this.cache.get(query, session, this.schema);
+      console.log('from cache: ', result);
+
+      if (!result) {
+        result = await this.get(query, session);
+
+        this.cache.put(query, session, result);
+      }
+
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  protected override process(mutations: M[], session: Session): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+
+  protected async get(query: Q, session: Session): Promise<T> {
+    const client = new CommercetoolsClient(this.config).getClient(
+      session.identity?.token
+    );
+
+    const remote = await client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .inventory()
+      .get({
+        queryArgs: {
+          where: 'sku=:sku',
+          'var.sku': query.sku,
+        },
+      })
+      .execute();
+
+    const base = this.newModel();
+
+    if (remote.body.results.length > 0) {
+      const inv = remote.body.results[0];
+
+      base.quantity = inv.availableQuantity;
+    }
+
+    return base;
+  }
+}

package/providers/commercetools/src/providers/price.provider.ts

@@ -0,0 +1,66 @@
+import { BaseCachingStrategy, BaseMutation, Price, PriceProvider, PriceQuery, RedisCache, Session } from '@reactionary/core';
+import z from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { CommercetoolsClient } from '../core/client';
+import { PriceMutation } from 'core/src/schemas/mutations/price.mutation';
+
+export class CommercetoolsPriceProvider<
+  T extends Price = Price,
+  Q extends PriceQuery = PriceQuery,
+  M extends PriceMutation = PriceMutation
+> extends PriceProvider<T, Q, M> {
+  protected config: CommercetoolsConfiguration;
+
+  constructor(config: CommercetoolsConfiguration, 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 client = new CommercetoolsClient(this.config).getClient(
+      session.identity?.token
+    );
+
+    const queryArgs = {
+      where: 'sku in :skus',
+      'var.skus': queries.map(x => x.sku.key),
+    };
+
+    const remote = await client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .standalonePrices()
+      .get({
+        queryArgs,
+      })
+      .execute();
+
+    const results = new Array<T>();
+    
+    for (const query of queries) {
+        const base = this.newModel();
+        const matched = remote.body.results.find(x => x.sku === query.sku.key);
+
+        if (matched) {
+          base.value = {
+            cents: matched.value.centAmount,
+            currency: 'USD',
+          };
+        }
+
+        base.identifier = {
+          sku: {
+            key: query.sku.key
+          }
+        };
+
+        results.push(base);
+    }
+
+    return results;
+  }
+
+  protected override process(mutation: BaseMutation[], session: Session): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+}

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

@@ -0,0 +1,90 @@
+import {
+  ProductProvider,
+  ProductQuery,
+  Product,
+  Session,
+  BaseMutation,
+  ProductMutation,
+} from '@reactionary/core';
+import { CommercetoolsClient } from '../core/client';
+import { z } from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { ProductProjection } from '@commercetools/platform-sdk';
+
+export class CommercetoolsProductProvider<
+  T extends Product = Product,
+  Q extends ProductQuery = ProductQuery,
+  M extends ProductMutation = ProductMutation
+> extends ProductProvider<T, Q, M> {
+  protected config: CommercetoolsConfiguration;
+
+  constructor(config: CommercetoolsConfiguration, 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: ProductQuery[], session: Session): Promise<T[]> {
+    const ids = queries.filter((x) => x.query === 'id').map((x) => x.id);
+    const slugs = queries.filter((x) => x.query === 'slug').map((x) => x.slug);
+
+    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+
+    const remote = await client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .productProjections()
+      .get({
+        queryArgs: {
+          where: 'slug(en-US in :slugs)',
+          'var.slugs': slugs
+        }
+      })
+      .execute();
+
+    console.log('remote: ', remote);
+
+    const results = new Array<T>;
+
+    for (const r of remote.body.results) {
+      const result = this.parse(r);
+
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  protected override process(
+    mutation: BaseMutation[],
+    session: Session
+  ): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+
+  protected parse(data: ProductProjection): T {
+    const base = this.newModel();
+
+    base.identifier.key = data.id;
+    base.name = data.name['en-US'];
+    base.slug = data.slug['en-US'];
+
+    if (data.description) {
+      base.description = data.description['en-US'];
+    }
+
+    if (data.masterVariant.images) {
+      base.image = data.masterVariant.images[0].url;
+    }
+
+    const variants = [data.masterVariant, ...data.variants];
+    for (const variant of variants) {
+      base.skus.push({
+        identifier: {
+          key: variant.sku || '',
+        },
+      });
+    }
+
+    return base;
+  }
+}

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

@@ -0,0 +1,86 @@
+import {
+  SearchIdentifier,
+  SearchMutation,
+  SearchProvider,
+  SearchQuery,
+  SearchResult,
+  SearchResultProductSchema,
+  Session,
+} from '@reactionary/core';
+import { CommercetoolsClient } from '../core/client';
+import z from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+
+export class CommercetoolsSearchProvider<
+  T extends SearchResult = SearchResult,
+  Q extends SearchQuery = SearchQuery,
+  M extends SearchMutation = SearchMutation
+> extends SearchProvider<T, Q, M> {
+  protected config: CommercetoolsConfiguration;
+
+  constructor(config: CommercetoolsConfiguration, 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.');
+  }
+
+  public async get(identifier: SearchIdentifier): Promise<T> {
+    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+
+    const remote = await client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .productProjections()
+      .search()
+      .get({
+        queryArgs: {
+          limit: identifier.pageSize,
+          offset: identifier.pageSize * identifier.page,
+          ['text.en-US']: identifier.term,
+        },
+      })
+      .execute();
+
+    const parsed = this.parse(remote, identifier);
+
+    return parsed;
+  }
+
+  public parse(remote: any, query: SearchIdentifier): T {
+    const result = super.newModel();
+
+    result.identifier = query;
+
+    for (const p of remote.body.results) {
+      const product = SearchResultProductSchema.parse({});
+
+      product.identifier.key = p.id;
+      product.name = p.name['en-US'];
+
+      if (p.masterVariant.images) {
+        product.image = p.masterVariant.images[0].url;
+      }
+
+      result.products.push(product);
+    }
+
+    result.pages = Math.ceil((remote.body.total || 0) / query.pageSize);
+
+    return result;
+  }
+}

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

@@ -0,0 +1,13 @@
+import { CapabilitiesSchema, Price, PriceQuery } from "@reactionary/core";
+import { z } from 'zod';
+
+export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
+    product: true,
+    search: true,
+    identity: true,
+    cart: true,
+    inventory: true,
+    price: true
+}).partial();
+
+export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const CommercetoolsConfigurationSchema = z.looseInterface({
+    projectKey: z.string(),
+    authUrl: z.string(),
+    apiUrl: z.string(),
+    clientId: z.string(),
+    clientSecret: z.string()
+});
+
+export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;

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

@@ -0,0 +1,20 @@
+import { ProductSchema } from '@reactionary/core';
+import { CommercetoolsProductProvider } from '../providers/product.provider';
+
+describe('Commercetools Product Provider', () => {
+  it('should be able to get a product by id', async () => {
+    const provider = new CommercetoolsProductProvider({
+        apiUrl: process.env['COMMERCETOOLS_API_URL'] || '',
+        authUrl: process.env['COMMERCETOOLS_AUTH_URL'] || '',
+        clientId: process.env['COMMERCETOOLS_CLIENT_ID'] || '',
+        clientSecret: process.env['COMMERCETOOLS_CLIENT_SECRET'] || '',
+        projectKey: process.env['COMMERCETOOLS_PROJECT_KEY'] || ''
+    }, 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://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg');
+  });
+});

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

@@ -0,0 +1,18 @@
+import { SearchResultSchema } from '@reactionary/core';
+import { CommercetoolsSearchProvider } from '../providers/search.provider';
+
+describe('Commercetools Search Provider', () => {
+  it('should be able to get a result by term', async () => {
+    const provider = new CommercetoolsSearchProvider({
+      apiUrl: process.env['COMMERCETOOLS_API_URL'] || '',
+      authUrl: process.env['COMMERCETOOLS_AUTH_URL'] || '',
+      clientId: process.env['COMMERCETOOLS_CLIENT_ID'] || '',
+      clientSecret: process.env['COMMERCETOOLS_CLIENT_SECRET'] || '',
+      projectKey: process.env['COMMERCETOOLS_PROJECT_KEY'] || '',
+    }, SearchResultSchema);
+
+    const result = await provider.get({ term: 'glass', page: 0, pageSize: 20, facets: [] });
+
+    expect(result.products.length).toBeGreaterThan(0);
+  });
+});

package/providers/commercetools/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/providers/commercetools/tsconfig.lib.json

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

package/providers/commercetools/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}

package/providers/fake/README.md

@@ -0,0 +1,7 @@
+# Fake
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build provider-fake` to build the library.

package/providers/fake/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/fake/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@reactionary/provider-fake",
+  "version": "0.0.1",
+  "dependencies": {
+    "@reactionary/core": "0.0.1",
+    "zod": "4.0.0-beta.20250430T185432",
+    "@faker-js/faker": "^9.8.0"
+  }
+}

package/providers/fake/project.json

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

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

@@ -0,0 +1,24 @@
+import { Client, IdentityMutationSchema, IdentityQuerySchema, IdentitySchema, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, SearchResultSchema } from "@reactionary/core";
+import { FakeProductProvider } from "../providers/product.provider";
+import { FakeSearchProvider } from "../providers/search.provider";
+import { FakeConfiguration } from "../schema/configuration.schema";
+import { FakeCapabilities } from "../schema/capabilities.schema";
+import { FakeIdentityProvider } from "../providers/identity.provider";
+
+export function withFakeCapabilities(configuration: FakeConfiguration, capabilities: FakeCapabilities) {
+    const client = {} as Partial<Client>;
+
+    if (capabilities.product) {
+        client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
+    }
+
+    if (capabilities.search) {
+        client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
+    }
+
+    if (capabilities.identity) {
+        client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
+    }
+
+    return client;
+}

package/providers/fake/src/index.ts

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