@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const CommercetoolsSessionSchema = z.looseObject({
+    token: z.string().default(''),
+    refreshToken: z.string().optional(),
+    expirationTime: z.number().default(0)
+});

package/providers/commercetools/src/test/caching.spec.ts

@@ -0,0 +1,82 @@
+import 'dotenv/config';
+import { assert, describe, expect, it } from 'vitest';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
+import {
+  createInitialRequestContext,
+  MemoryCache,
+  type ProductIdentifier,
+  type ProductSearchQueryByTerm,
+} from '@reactionary/core';
+import { CommercetoolsProductProvider } from '../providers/product.provider.js';
+import { CommercetoolsClient } from '../core/client.js';
+import { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
+
+describe('Caching', () => {
+  it('should cache repeat look-ups for products', async () => {
+    const config = getCommercetoolsTestConfiguration();
+    const context = createInitialRequestContext();
+    const cache = new MemoryCache();
+    const client = new CommercetoolsClient(config, context);
+    const provider = new CommercetoolsProductProvider(config, cache, context, client);
+
+    const identifier = {
+        key: 'product_10959528'
+    } satisfies ProductIdentifier;
+
+    const uncached = await provider.getById({
+        identifier
+    });
+
+    if (!uncached.success) {
+      assert.fail();
+    }
+
+    expect(uncached.meta.cache.hit).toBe(false);
+
+    const cached = await provider.getById({
+        identifier
+    });
+
+    if (!cached.success) {
+      assert.fail();
+    }
+
+    expect(cached.meta.cache.hit).toBe(true);
+  });
+
+  it('should cache repeat look-ups for product search', async () => {
+    const config = getCommercetoolsTestConfiguration();
+    const context = createInitialRequestContext();
+    const cache = new MemoryCache();
+    const client = new CommercetoolsClient(config, context);
+    const provider = new CommercetoolsSearchProvider(config, cache, context, client);
+
+    const query = {
+      search: {
+        facets: [],
+        filters: [],
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 10
+        },
+        term: 'laptop'
+      }
+    } satisfies ProductSearchQueryByTerm;
+
+    const uncached = await provider.queryByTerm(query);
+
+    if (!uncached.success) {
+      assert.fail();
+    }
+
+    expect(uncached.meta.cache.hit).toBe(false);
+
+    const cached = await provider.queryByTerm(query);
+
+    if (!cached.success) {
+      assert.fail();
+    }
+
+    expect(cached.meta.cache.hit).toBe(true);
+  });
+});

package/providers/commercetools/src/test/identity.spec.ts

@@ -0,0 +1,109 @@
+import 'dotenv/config';
+import { describe, expect, it } from 'vitest';
+import { CommercetoolsClient } from '../core/client.js';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
+import {
+  createInitialRequestContext,
+  type RequestContext,
+} from '@reactionary/core';
+import type { ApiRoot } from '@commercetools/platform-sdk';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+
+function setup() {
+  const config = getCommercetoolsTestConfiguration();
+  const context = createInitialRequestContext();
+  const root = new CommercetoolsClient(config, context);
+
+  return {
+    config,
+    context,
+    root,
+  };
+}
+
+async function createCart(
+  client: ApiRoot,
+  context: RequestContext,
+  config: CommercetoolsConfiguration
+) {
+  const cart = await client
+    .withProjectKey({ projectKey: config.projectKey })
+    .me()
+    .carts()
+    .post({
+      body: {
+        currency: context.languageContext.currencyCode,
+        lineItems: [
+          {
+            sku: '0766623301831',
+            distributionChannel: {
+              typeId: 'channel',
+              key: 'OnlineFfmChannel',
+            },
+          },
+        ],
+      },
+    })
+    .execute();
+
+  return cart;
+}
+
+describe('Commercetools Identity', () => {
+  it('initially is considered anonymous', async () => {
+    const { root } = setup();
+
+    const initialSelf = await root.introspect();
+    expect(initialSelf.type).toBe('Anonymous');
+  });
+
+  it('becomes a guest when acquiring a client for user operations', async () => {
+    const { root } = setup();
+
+    const client = await root.getClient();
+    const guestSelf = await root.introspect();
+    expect(guestSelf.type).toBe('Guest');
+  });
+
+it('can login from being anonymous', async () => {
+    const { config, context, root } = setup();
+
+    // After a login, we are expected to be Registered
+    const identity = await root.login('asger.jensen3@solteq.com', 'test12345');
+    expect(identity.type).toBe('Registered');
+
+    // And we expect the introspected result of what is in token-cache to match that...
+    const introspectedRegisteredIdentity = await root.introspect();
+    expect(introspectedRegisteredIdentity.type).toBe('Registered');
+
+    // Finally, we expect to be able to perform an add-to-cart (only acquiring client AFTER being logged in)
+    const client = await root.getClient();
+    const cart = await createCart(client, context, config);
+
+    expect(cart.body.id).toBeDefined();
+    expect(cart.body.lineItems.length).toBe(1);
+    expect(cart.body.customerId).toBe(identity.id.userId);
+  });
+
+  it('can login from being guest', async () => {
+    const { config, context, root } = setup();
+
+    // Become guest by acquiring a client
+    const client = await root.getClient();
+
+    // After a login, we are expected to be Registered
+    const identity = await root.login('asger.jensen3@solteq.com', 'test12345');
+    expect(identity.type).toBe('Registered');
+
+    // And we expect the introspected result of what is in token-cache to match that...
+    const introspectedRegisteredIdentity = await root.introspect();
+    expect(introspectedRegisteredIdentity.type).toBe('Registered');
+
+    // Finally, we expect to be able to perform an add-to-cart
+    const cart = await createCart(client, context, config);
+
+    expect(cart.body.id).toBeDefined();
+    expect(cart.body.lineItems.length).toBe(1);
+    expect(cart.body.customerId).toBe(identity.id.userId);
+  });
+});

package/providers/commercetools/src/test/test-utils.ts

@@ -1,25 +1,27 @@
-import { PaymentMethodSchema } from '@reactionary/core';
+import { PaymentMethodSchema, type PaymentMethod, type PaymentMethodIdentifier } from '@reactionary/core';
 import { PaymentMethodIdentifierSchema } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 
 export function getCommercetoolsTestConfiguration() {
   return {
-        apiUrl: process.env['CTP_API_URL'] || '',
-        authUrl: process.env['CTP_AUTH_URL'] || '',
-        clientId: process.env['CTP_CLIENT_ID'] || '',
-        clientSecret: process.env['CTP_CLIENT_SECRET'] || '',
-        projectKey: process.env['CTP_PROJECT_KEY'] || '',
-        scopes: (process.env['CTP_SCOPES'] || '').split(',').map(x => x.trim()).filter(x => x && x.length > 0),
+    apiUrl: process.env['CTP_API_URL'] || '',
+    authUrl: process.env['CTP_AUTH_URL'] || '',
+    clientId: process.env['CTP_CLIENT_ID'] || '',
+    clientSecret: process.env['CTP_CLIENT_SECRET'] || '',
+    projectKey: process.env['CTP_PROJECT_KEY'] || '',
+    scopes: (process.env['CTP_SCOPES'] || '').split(',').map(x => x.trim()).filter(x => x && x.length > 0),
 
-        paymentMethods: [
-          PaymentMethodSchema.parse({
-            identifier: PaymentMethodIdentifierSchema.parse({
-              paymentProvider: 'stripe',
-              method: 'stripe',
-              name: 'Stripe',
-            }),
-            description: 'Stripe payment gateway'
-          })
-        ]
-    }
+    paymentMethods: [
+      PaymentMethodSchema.parse({
+        identifier: PaymentMethodIdentifierSchema.parse({
+          paymentProcessor: 'stripe',
+          method: 'stripe',
+          name: 'Stripe',
+        } satisfies Partial<PaymentMethodIdentifier>),
+        description: 'Stripe payment gateway',
+        isPunchOut: true,
+      } satisfies Partial<PaymentMethod>),
+    ],
+    facetFieldsForSearch: []
+  } satisfies CommercetoolsConfiguration
 }
-

package/providers/commercetools/tsconfig.json

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

package/providers/commercetools/tsconfig.lib.json

@@ -6,5 +6,5 @@
     "types": ["node"]
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts", "src/**/test-utils.ts"]
+  "exclude": ["src/**/*.spec.ts", "src/**/*.test.ts", "src/**/test-utils.ts"]
 }

package/providers/commercetools/tsconfig.spec.json

@@ -1,16 +1,4 @@
 {
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "verbatimModuleSyntax": false,
-    "outDir": "../../dist/out-tsc",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "jest.config.cjs",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-  ]
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
 }

package/providers/commercetools/vitest.config.ts

@@ -0,0 +1,15 @@
+/// <reference types="vitest" />
+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,js}', 'src/**/*.test.ts'],
+  },
+});

package/providers/fake/README.md

@@ -1,7 +1,23 @@
-# Fake
+# Fake provider for Reactionary
 
-This library was generated with [Nx](https://nx.dev).
+## Supports
 
-## Building
 
-Run `nx build provider-fake` to build the library.
+
+| Feature | Support | Notes |
+| -----------   | ----------- | --------- |
+| product       | Full      |          |
+| productSearch | Full     |  |
+| identity | Full     | |
+| cart | Full     |  |
+| checkout | Planned     |  |
+| order | Planned     |  |
+| inventory | Full     |  |
+| price | Full   |  |
+| category | Full     |  |
+| store | Full    |  |
+
+
+## Notes
+
+Not as many different product names as we would have liked. Maybe we need to create our own faker test data.

package/providers/fake/package.json

@@ -8,5 +8,6 @@
     "zod": "4.1.9",
     "@faker-js/faker": "^9.8.0"
   },
-  "type": "module"
+  "type": "module",
+  "sideEffects": false
 }

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

@@ -1,95 +1,93 @@
 import type {
   Cache as ReactinaryCache,
-  ProductProvider,
-  SearchProvider,
-  IdentityProvider,
-  CategoryProvider,
-  CartProvider,
-  InventoryProvider,
-  StoreProvider,
-  PriceProvider,
-} from '@reactionary/core';
-import {
-  ProductSchema,
-  SearchResultSchema,
-  CategorySchema,
-  CartSchema,
-  InventorySchema,
-  StoreSchema,
-  PriceSchema,
+  RequestContext,
+  ClientFromCapabilities,
 } from '@reactionary/core';
 import { FakeProductProvider } from '../providers/product.provider.js';
-import { FakeSearchProvider } from '../providers/search.provider.js';
+import { FakeSearchProvider } from '../providers/product-search.provider.js';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import type { FakeCapabilities } from '../schema/capabilities.schema.js';
 import { FakeCategoryProvider } from '../providers/category.provider.js';
 import {
   FakeCartProvider,
+  FakeIdentityProvider,
   FakeInventoryProvider,
   FakePriceProvider,
   FakeStoreProvider,
 } from '../providers/index.js';
-
-type FakeClient<T extends FakeCapabilities> = (T['cart'] extends true
-  ? { cart: CartProvider }
-  : object) &
-  (T['product'] extends true ? { product: ProductProvider } : object) &
-  (T['search'] extends true ? { search: SearchProvider } : object) &
-  (T['identity'] extends true ? { identity: IdentityProvider } : object) &
-  (T['category'] extends true ? { category: CategoryProvider } : object) &
-  (T['inventory'] extends true ? { inventory: InventoryProvider } : object) &
-  (T['store'] extends true ? { store: StoreProvider } : object) &
-  (T['price'] extends true ? { price: PriceProvider } : object);
+import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
+import { FakeOrderProvider } from '../providers/order.provider.js';
+import { FakeProfileProvider } from '../providers/profile.provider.js';
 
 export function withFakeCapabilities<T extends FakeCapabilities>(
   configuration: FakeConfiguration,
   capabilities: T
 ) {
-  return (cache: ReactinaryCache): FakeClient<T> => {
+  return (
+    cache: ReactinaryCache,
+    context: RequestContext
+  ): ClientFromCapabilities<T> => {
     const client: any = {};
 
     if (capabilities.product) {
-      client.product = new FakeProductProvider(
-        configuration,
-        ProductSchema,
-        cache
-      );
+      client.product = new FakeProductProvider(configuration, cache, context);
     }
 
-    if (capabilities.search) {
-      client.search = new FakeSearchProvider(
+    if (capabilities.productSearch) {
+      client.productSearch = new FakeSearchProvider(
         configuration,
-        SearchResultSchema,
-        cache
+        cache,
+        context
       );
     }
 
     if (capabilities.category) {
-      client.category = new FakeCategoryProvider(
-        configuration,
-        CategorySchema,
-        cache
-      );
+      client.category = new FakeCategoryProvider(configuration, cache, context);
     }
 
     if (capabilities.cart) {
-      client.cart = new FakeCartProvider(configuration, CartSchema, cache);
+      client.cart = new FakeCartProvider(configuration, cache, context);
     }
 
     if (capabilities.inventory) {
       client.inventory = new FakeInventoryProvider(
         configuration,
-        InventorySchema,
-        cache
+        cache,
+        context
       );
     }
 
     if (capabilities.store) {
-      client.store = new FakeStoreProvider(configuration, StoreSchema, cache);
+      client.store = new FakeStoreProvider(configuration, cache, context);
     }
 
     if (capabilities.price) {
-      client.price = new FakePriceProvider(configuration, PriceSchema, cache);
+      client.price = new FakePriceProvider(configuration, cache, context);
+    }
+
+    if (capabilities.identity) {
+      client.identity = new FakeIdentityProvider(configuration, cache, context);
+    }
+
+    if (capabilities.checkout) {
+      client.checkout = new FakeCheckoutProvider(configuration, cache, context);
+    }
+
+    if (capabilities.orderSearch) {
+      client.orderSearch = new FakeOrderSearchProvider(
+        configuration,
+        cache,
+        context
+      );
+    }
+
+    if (capabilities.order) {
+      client.order = new FakeOrderProvider(configuration, cache, context);
+    }
+
+    if (capabilities.profile) {
+      client.profile = new FakeProfileProvider(configuration, cache, context);
     }
 
     return client;

package/providers/fake/src/providers/analytics.provider.ts

@@ -1,19 +1,17 @@
 import type {
-  BaseModel,
-  Cache} from '@reactionary/core';
+  Cache,
+  RequestContext} from '@reactionary/core';
 import {
   AnalyticsProvider
 } from '@reactionary/core';
 import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 
-export class FakeAnalyticsProvider<
-  T extends BaseModel = BaseModel
-> extends AnalyticsProvider<T> {
+export class FakeAnalyticsProvider extends AnalyticsProvider {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
+  constructor(config: FakeConfiguration, cache: Cache, context: RequestContext) {
+    super(cache, context);
 
     this.config = config;
   }