@reactionary/source 0.0.52 → 0.2.16

package/providers/algolia/tsconfig.json

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

package/providers/algolia/tsconfig.lib.json

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

package/providers/algolia/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.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-  ]
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
 }

package/providers/algolia/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/commercetools/README.md

@@ -1,6 +1,33 @@
-# provider-commercetools
+# Commmercetools provider for Reactionary
+
+## Supports
+
+
+| Feature | Support | Notes |
+| -----------   | ----------- | --------- |
+| product       | Full      |          |
+| productSearch | Full     |  |
+| identity | Full     | |
+| cart | Full     |  |
+| checkout | Full     |  |
+| order | Full     |  |
+| inventory | Full     |  |
+| price | Full   |  |
+| category | Full     |  |
+| store | Full    |  |
+
+
+## Notes
+
+
+
+
+
+
+
+
+
 
-This library was generated with [Nx](https://nx.dev).
 
 ## Building
 
@@ -11,7 +38,7 @@ Run `nx build provider-commercetools` to build the library.
 Run `nx test provider-commercetools` to execute the unit tests via [Jest](https://jestjs.io).
 
 
-# ASSUMPTIONS for backend config
+## Assumptions for backend config
 
 - You will have 2 different channels for prices, one called `Offer Price` and one called `List Price`
 - ProductVariants will all have unique SKU values.

package/providers/commercetools/package.json

@@ -10,5 +10,6 @@
     "@commercetools/ts-client": "^4.2.1",
     "@commercetools/platform-sdk": "^8.8.0"
   },
-  "type": "module"
+  "type": "module",
+  "sideEffects": false
 }

package/providers/commercetools/src/core/client.ts

@@ -1,70 +1,92 @@
+import { ClientBuilder } from '@commercetools/ts-client';
 import {
-  ClientBuilder,
-  type TokenCache,
-  type TokenCacheOptions,
-  type TokenStore,
-} from '@commercetools/ts-client';
-import { createApiBuilderFromCtpClient } from '@commercetools/platform-sdk';
+  createApiBuilderFromCtpClient,
+  type ApiRoot,
+} from '@commercetools/platform-sdk';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import { randomUUID } from 'crypto';
 import {
   AnonymousIdentitySchema,
-  GuestIdentitySchema,
   RegisteredIdentitySchema,
+  type AnonymousIdentity,
+  type GuestIdentity,
+  type RegisteredIdentity,
   type RequestContext,
 } from '@reactionary/core';
 import * as crypto from 'crypto';
-import createDebug from 'debug'
-const debug = createDebug('commercetools:debug')
+import createDebug from 'debug';
+import { RequestContextTokenCache } from './token-cache.js';
+const debug = createDebug('reactionary:commercetools');
 
+export class CommercetoolsAPI {
+  protected config: CommercetoolsConfiguration;
+  protected context: RequestContext;
+  protected cache: RequestContextTokenCache;
+  protected client: Promise<ApiRoot> | undefined;
+  protected adminClient: Promise<ApiRoot> | undefined;
 
+  constructor(config: CommercetoolsConfiguration, context: RequestContext) {
+    this.config = config;
+    this.context = context;
+    this.cache = new RequestContextTokenCache(this.context);
+  }
 
+  public async getClient() {
+    if (!this.client) {
+      this.client = this.createClient();
+    }
 
-export class RequestContextTokenCache implements TokenCache {
-  constructor(protected context: RequestContext) {}
+    return this.client;
+  }
 
-  public async get(
-    tokenCacheOptions?: TokenCacheOptions
-  ): Promise<TokenStore | undefined> {
-    const identity = this.context.identity;
+  public async getAdminClient() {
+    if (!this.adminClient) {
+      this.adminClient = this.createAdminClient();
+    }
 
-    return {
-      refreshToken: identity.refresh_token,
-      token: identity.token || '',
-      expirationTime: identity.expiry.getTime(),
-    };
+    return this.adminClient;
   }
 
-  public async set(
-    cache: TokenStore,
-    tokenCacheOptions?: TokenCacheOptions
-  ): Promise<void> {
-    const identity = this.context.identity;
+  protected async createAdminClient() {
+    let builder = this.createBaseClientBuilder();
+    builder = builder.withAnonymousSessionFlow({
+      credentials: {
+        clientId: this.config.clientId,
+        clientSecret: this.config.clientSecret,
+      },
+      host: this.config.authUrl,
+      projectKey: this.config.projectKey,
+    });
 
-    identity.refresh_token = cache.refreshToken;
-    identity.token = cache.token;
-    identity.expiry = new Date(cache.expirationTime);
+    return createApiBuilderFromCtpClient(builder.build());
   }
-}
 
+  protected async createClient() {
+    let session = await this.cache.get();
+    const isNewSession = !session || !session.refreshToken;
 
+    if (isNewSession) {
+      await this.becomeGuest();
 
-export class CommercetoolsClient {
-  protected config: CommercetoolsConfiguration;
+      session = await this.cache.get();
+    }
 
-  constructor(config: CommercetoolsConfiguration) {
-    this.config = config;
-  }
+    let builder = this.createBaseClientBuilder();
+    builder = builder.withRefreshTokenFlow({
+      credentials: {
+        clientId: this.config.clientId,
+        clientSecret: this.config.clientSecret,
+      },
+      host: this.config.authUrl,
+      projectKey: this.config.projectKey,
+      refreshToken: session?.refreshToken || '',
+      tokenCache: this.cache,
+    });
 
-  public async getClient(reqCtx: RequestContext) {
-    return this.createClient(reqCtx);
+    return createApiBuilderFromCtpClient(builder.build());
   }
 
-  public async register(
-    username: string,
-    password: string,
-    reqCtx: RequestContext
-  ) {
+  public async register(username: string, password: string) {
     const registrationBuilder =
       this.createBaseClientBuilder().withAnonymousSessionFlow({
         host: this.config.authUrl,
@@ -92,19 +114,13 @@ export class CommercetoolsClient {
       })
       .execute();
 
-    const login = await this.login(username, password, reqCtx);
+    const login = await this.login(username, password);
 
     return login;
   }
 
-  public async login(
-    username: string,
-    password: string,
-    reqCtx: RequestContext
-  ) {
-    const cache = new RequestContextTokenCache(reqCtx);
-
-    const loginBuilder = this.createBaseClientBuilder().withPasswordFlow({
+  public async login(username: string, password: string) {
+  const loginBuilder = this.createBaseClientBuilder().withPasswordFlow({
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
       credentials: {
@@ -112,7 +128,7 @@ export class CommercetoolsClient {
         clientSecret: this.config.clientSecret,
         user: { username, password },
       },
-      tokenCache: cache,
+      tokenCache: this.cache,
       scopes: this.config.scopes,
     });
 
@@ -130,78 +146,136 @@ export class CommercetoolsClient {
       })
       .execute();
 
-    reqCtx.identity = RegisteredIdentitySchema.parse({
-      ...reqCtx.identity,
+    const self = await loginClient
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .me()
+      .get({})
+      .execute();
+
+    return RegisteredIdentitySchema.parse({
       type: 'Registered',
-      logonId: username,
       id: {
-        userId: login.body.customer.id,
+        userId: self.body.id,
       },
     });
+  }
 
-    return reqCtx.identity;
+  public async logout() {
+    await this.cache.set({ token: '', refreshToken: '', expirationTime: 0 });
+
+    // TODO: We could do token revocation here, if we wanted to. The above simply whacks the session.
+    const identity = {
+      type: 'Anonymous'
+    } satisfies AnonymousIdentity;
+    return identity;
   }
 
-  public async logout(reqCtx: RequestContext) {
-    const cache = new RequestContextTokenCache(reqCtx);
-    await cache.set({ token: '', refreshToken: '', expirationTime: 0 });
+  // FIXME: This can fail if the short-lived access token has expired. In other words, probably missing a token refresh.
+  public async introspect(): Promise<
+    AnonymousIdentity | GuestIdentity | RegisteredIdentity
+  > {
+    const session = await this.cache.get();
 
-    reqCtx.identity = AnonymousIdentitySchema.parse({});
+    if (!session || !session.token) {
+      const identity = {
+        type: 'Anonymous'
+      } satisfies AnonymousIdentity;
 
-    // TODO: We could do token revocation here, if we wanted to. The above simply whacks the session.
+      return identity;
+    }
 
-    return reqCtx.identity;
-  }
+    const authHeader =
+      'Basic ' +
+      Buffer.from(
+        `${this.config.clientId}:${this.config.clientSecret}`
+      ).toString('base64');
+    const introspectionUrl = `${this.config.authUrl}/oauth/introspect`;
+
+    const response = await fetch(introspectionUrl, {
+      method: 'POST',
+      headers: {
+        Authorization: authHeader,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams({
+        token: session.token,
+      }),
+    });
 
-  protected createClient(reqCtx: RequestContext) {
-    const cache = new RequestContextTokenCache(reqCtx);
 
-    if (reqCtx.identity.type === 'Anonymous') {
-      reqCtx.identity = GuestIdentitySchema.parse({
+    const body = await response.json();
+    if (!body) {
+      return AnonymousIdentitySchema.parse({});
+    }
+
+    const scopes: string = body.scope + '';
+
+    // FIXME: Map unmapped user_id...
+    if (scopes.indexOf('anonymous_id') > -1) {
+      const s = scopes.split(' ');
+      const idScope = s.find((x) => x.startsWith('anonymous_id'));
+      const id = idScope?.split(':')[1] || '';
+      const identity = {
         id: {
-          userId: crypto.randomUUID().toString(),
+          userId: id,
         },
         type: 'Guest',
-      });
-    }
+      } satisfies GuestIdentity;
 
-    const identity = reqCtx.identity;
-    let builder = this.createBaseClientBuilder(reqCtx);
+      return identity;
+    }
 
-    if (!identity.token || !identity.refresh_token) {
-      builder = builder.withAnonymousSessionFlow({
-        host: this.config.authUrl,
-        projectKey: this.config.projectKey,
-        credentials: {
-          clientId: this.config.clientId,
-          clientSecret: this.config.clientSecret,
-          anonymousId: identity.id.userId,
-        },
-        tokenCache: cache,
-      });
-    } else {
-      builder = builder.withRefreshTokenFlow({
-        credentials: {
-          clientId: this.config.clientId,
-          clientSecret: this.config.clientSecret,
+    // FIXME: Map unmapped user_id...
+    if (scopes.indexOf('customer_id') > -1) {
+      const s = scopes.split(' ');
+      const idScope = s.find((x: any) => x.startsWith('customer_id'));
+      const id = idScope?.split(':')[1] || '';
+      const identity = {
+        id: {
+          userId: id,
         },
-        host: this.config.authUrl,
-        projectKey: this.config.projectKey,
-        refreshToken: identity.refresh_token || '',
-        tokenCache: cache,
-      });
+        type: 'Registered',
+      } satisfies RegisteredIdentity;
+
+      return identity;
     }
 
-    return createApiBuilderFromCtpClient(builder.build());
+    return {
+      type: 'Anonymous',
+    } satisfies AnonymousIdentity;
   }
 
+  protected async becomeGuest() {
+    const credentials = Buffer.from(
+      `${this.config.clientId}:${this.config.clientSecret}`
+    ).toString('base64');
+
+    // FIXME: Missing scope-down from .env scopes list
+    const response = await fetch(
+      `${this.config.authUrl}/oauth/${this.config.projectKey}/anonymous/token?grant_type=client_credentials`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Basic ${credentials}`,
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+          grant_type: 'client_credentials',
+        }),
+      }
+    );
 
+    const result = await response.json();
 
+    this.cache.set({
+      expirationTime:
+        Date.now() + Number(result.expires_in) * 1000 - 5 * 60 * 1000,
+      token: result.access_token,
+      refreshToken: result.refresh_token,
+    });
+  }
 
-
-
-
-  protected createBaseClientBuilder(reqCtx?: RequestContext) {
+  protected createBaseClientBuilder() {
     let builder = new ClientBuilder()
       .withProjectKey(this.config.projectKey)
       .withQueueMiddleware({
@@ -237,7 +311,12 @@ export class CommercetoolsClient {
         httpClient: fetch,
       });
 
-    const correlationId = reqCtx?.correlationId || 'REACTIONARY-' + (typeof crypto !== 'undefined' && 'randomUUID' in crypto ? crypto.randomUUID() : randomUUID());
+    const correlationId =
+      this.context.correlationId ||
+      'REACTIONARY-' +
+        (typeof crypto !== 'undefined' && 'randomUUID' in crypto
+          ? crypto.randomUUID()
+          : randomUUID());
     builder = builder.withCorrelationIdMiddleware({
       generate: () => correlationId,
     });