@reactionary/source 0.0.42 → 0.0.48

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

@@ -1,125 +1,179 @@
-import { ClientBuilder } from '@commercetools/ts-client';
+import {
+  ClientBuilder,
+  type TokenCache,
+  type TokenCacheOptions,
+  type TokenStore,
+} from '@commercetools/ts-client';
 import { createApiBuilderFromCtpClient } from '@commercetools/platform-sdk';
-import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { randomUUID } from 'crypto';
-
-
-export class CommercetoolsClient {
-  protected config: CommercetoolsConfiguration;
-
-  constructor(config: CommercetoolsConfiguration) {
-    this.config = config;
-  }
-
-  public getClient(token?: string) {
-    if (token) {
-      return this.createClientWithToken(token);
+import { GuestIdentitySchema, IdentitySchema, type RequestContext } from '@reactionary/core';
+import * as crypto from 'crypto';
+
+export class RequestContextTokenCache implements TokenCache {
+  constructor(protected context: RequestContext) {}
+
+  public async get(
+    tokenCacheOptions?: TokenCacheOptions
+  ): Promise<TokenStore | undefined> {
+    const identity = this.context.identity;
+
+    if (identity.type !== 'Anonymous') {
+      return {
+        refreshToken: identity.refresh_token,
+        token: identity.token || '',
+        expirationTime: identity.expiry.getTime(),
+      };
     }
 
-    return this.createAnonymousClient();
+    return undefined;
   }
 
-  public async login(username: string, password: string) {
-    const queryParams = new URLSearchParams({
-      grant_type: 'password',
-      username: username,
-      password: password,
-    });
-    const url = `${this.config.authUrl}/oauth/${
-      this.config.projectKey
-    }/customers/token?${queryParams.toString()}`;
-    const headers = {
-      Authorization:
-        'Basic ' + btoa(this.config.clientId + ':' + this.config.clientSecret),
-    };
-
-    const remote = await fetch(url, { method: 'POST', headers });
-    const json = await remote.json();
+  public async set(
+    cache: TokenStore,
+    tokenCacheOptions?: TokenCacheOptions
+  ): Promise<void> {
+    const identity = this.context.identity;
 
-    return json;
+    identity.refresh_token = cache.refreshToken;
+    identity.token = cache.token;
+    identity.expiry = new Date(cache.expirationTime);
   }
+}
 
-  public async guest() {
-    const queryParams = new URLSearchParams({
-      grant_type: 'client_credentials',
-    });
-    const url = `${this.config.authUrl}/oauth/${
-      this.config.projectKey
-    }/anonymous/token?${queryParams.toString()}`;
-    const headers = {
-      Authorization:
-        'Basic ' + btoa(this.config.clientId + ':' + this.config.clientSecret),
-    };
-
-    const remote = await fetch(url, { method: 'POST', headers });
-    const json = await remote.json();
+export class CommercetoolsClient {
+  protected config: CommercetoolsConfiguration;
 
-    return json;
+  constructor(config: CommercetoolsConfiguration) {
+    this.config = config;
   }
 
-  public async logout(token: string) {
-    const queryParams = new URLSearchParams({
-      token: token,
-      token_type_hint: 'access_token',
-    });
-    const url = `${
-      this.config.authUrl
-    }/oauth/token/revoke?${queryParams.toString()}`;
-    const headers = {
-      Authorization:
-        'Basic ' + btoa(this.config.clientId + ':' + this.config.clientSecret),
-    };
-
-    const remote = await fetch(url, { method: 'POST', headers });
-
-    return remote;
+  public async getClient(reqCtx: RequestContext) {
+    return this.createClient(reqCtx);
   }
 
-  public async introspect(token: string) {
-    const queryParams = new URLSearchParams({
-      token,
-    });
-    const url = `${this.config.authUrl}/oauth/introspect?` + queryParams;
-    const headers = {
-      Authorization:
-        'Basic ' + btoa(this.config.clientId + ':' + this.config.clientSecret),
-    };
+  public async register(
+    username: string,
+    password: string,
+    reqCtx: RequestContext
+  ) {
+    const cache = new RequestContextTokenCache(reqCtx);
+
+    const registrationBuilder =
+      this.createBaseClientBuilder().withAnonymousSessionFlow({
+        host: this.config.authUrl,
+        projectKey: this.config.projectKey,
+        credentials: {
+          clientId: this.config.clientId,
+          clientSecret: this.config.clientSecret,
+        },
+        scopes: this.config.scopes,
+        tokenCache: cache,
+      });
 
-    const remote = await fetch(url, { method: 'POST', headers });
-    const json = await remote.json();
+    const registrationClient = createApiBuilderFromCtpClient(
+      registrationBuilder.build()
+    );
+    const registration = await registrationClient
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .me()
+      .signup()
+      .post({
+        body: {
+          email: username,
+          password: password,
+        },
+      })
+      .execute();
 
-    return json;
+    const login = await this.login(username, password, reqCtx);
   }
 
-  public createAnonymousClient() {
-    const scopes = this.config.scopes;
-    const builder = this.createBaseClientBuilder().withClientCredentialsFlow({
+  public async login(
+    username: string,
+    password: string,
+    reqCtx: RequestContext
+  ) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    const identity = reqCtx.identity;
+
+    const loginBuilder = this.createBaseClientBuilder().withPasswordFlow({
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
       credentials: {
         clientId: this.config.clientId,
         clientSecret: this.config.clientSecret,
+        user: { username, password },
       },
-      scopes: [...scopes],
+      tokenCache: cache,
+      scopes: this.config.scopes,
     });
 
-    return createApiBuilderFromCtpClient(builder.build());
-  }
+    const loginClient = createApiBuilderFromCtpClient(loginBuilder.build());
 
-  protected createClientWithToken(token: string) {
-    const builder = this.createBaseClientBuilder().withExistingTokenFlow(
-      `Bearer ${token}`,
-      { force: true }
-    );
+    const login = await loginClient
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .me()
+      .get()
+      .execute();
 
-    return createApiBuilderFromCtpClient(builder.build());
+    identity.type = 'Registered';
+    identity.logonId = username;
+    identity.id = {
+      userId: login.body.id
+    };
   }
 
+  public async logout(reqCtx: RequestContext) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    await cache.set({ token: '', refreshToken: '', expirationTime: 0 });
 
+    reqCtx.identity = IdentitySchema.parse({});
 
+    // TODO: We could do token revocation here, if we wanted to. The above simply whacks the session.
+  }
 
+  protected createClient(reqCtx: RequestContext) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    
+    if (reqCtx.identity.type === 'Anonymous') {
+      reqCtx.identity = GuestIdentitySchema.parse({
+        id: {
+          userId: crypto.randomUUID().toString(),
+        },
+        type: 'Guest'
+      });
+    }
 
+    const identity = reqCtx.identity;
+    let builder = this.createBaseClientBuilder();
+
+    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,
+        },
+        host: this.config.authUrl,
+        projectKey: this.config.projectKey,
+        refreshToken: identity.refresh_token || '',
+        tokenCache: cache,
+      });
+    }
 
+    return createApiBuilderFromCtpClient(builder.build());
+  }
 
   protected createBaseClientBuilder() {
     const builder = new ClientBuilder()
@@ -133,7 +187,9 @@ export class CommercetoolsClient {
           // And yes, ideally the frontend would handle this, but as the customer is not really in a position to DO anything about it,
           // we might as well just deal with it here.....
 
-          console.log(`Concurrent modification error, retry with version ${version}`);
+          console.log(
+            `Concurrent modification error, retry with version ${version}`
+          );
           const body = request.body as Record<string, any>;
           body['version'] = version;
           return Promise.resolve(body);

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

@@ -1,12 +1,5 @@
-import {
-    CartSchema,
-    IdentitySchema,
-    InventorySchema,
-    PriceSchema,
-    ProductSchema,
-    SearchResultSchema,
+import type {
     Cache,
-    CategorySchema,
     ProductProvider,
     SearchProvider,
     IdentityProvider,
@@ -14,12 +7,21 @@ import {
     InventoryProvider,
     PriceProvider,
     CategoryProvider,
+    StoreProvider} from "@reactionary/core";
+import {
+    CartSchema,
+    IdentitySchema,
+    InventorySchema,
+    PriceSchema,
+    ProductSchema,
+    SearchResultSchema,
+    CategorySchema,
     CartPaymentInstructionSchema
 } from "@reactionary/core";
-import { CommercetoolsCapabilities } from "../schema/capabilities.schema";
+import type { CommercetoolsCapabilities } from "../schema/capabilities.schema";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from '../providers/product.provider';
-import { CommercetoolsConfiguration } from "../schema/configuration.schema";
+import type { CommercetoolsConfiguration } from "../schema/configuration.schema";
 import { CommercetoolsIdentityProvider } from "../providers/identity.provider";
 import { CommercetoolsCartProvider } from "../providers/cart.provider";
 import { CommercetoolsInventoryProvider } from "../providers/inventory.provider";
@@ -34,7 +36,8 @@ type CommercetoolsClient<T extends CommercetoolsCapabilities> =
     (T['identity'] extends true ? { identity: IdentityProvider } : object) &
     (T['category'] extends true ? { category: CategoryProvider } : object) &
     (T['inventory'] extends true ? { inventory: InventoryProvider } : object) &
-    (T['price'] extends true ? { price: PriceProvider } : object);
+    (T['price'] extends true ? { price: PriceProvider } : object) &
+    (T['store'] extends true ? { store: StoreProvider } : object);
 
 export function withCommercetoolsCapabilities<T extends CommercetoolsCapabilities>(
     configuration: CommercetoolsConfiguration,

package/providers/commercetools/src/providers/cart-payment.provider.ts

@@ -1,12 +1,14 @@
 
-import { CommercetoolsConfiguration } from "../schema/configuration.schema";
+import type { CommercetoolsConfiguration } from "../schema/configuration.schema";
 import { CommercetoolsClient } from "../core/client";
-import { Payment as CTPayment, PaymentStatus } from "@commercetools/platform-sdk";
+import type { Payment as CTPayment} from "@commercetools/platform-sdk";
+import { PaymentStatus } from "@commercetools/platform-sdk";
 import { traced } from "@reactionary/otel";
-import { CommercetoolsCartIdentifier, CommercetoolsCartIdentifierSchema, CommercetoolsCartPaymentInstructionIdentifierSchema } from "../schema/commercetools.schema";
-import { Cache, CartPaymentInstruction,  CartPaymentProvider, Currency, PaymentMethodIdentifierSchema,  } from "@reactionary/core";
-import type { CartPaymentQueryByCart, CartPaymentMutationAddPayment, CartPaymentMutationCancelPayment, Session } from "@reactionary/core";
-import z from "zod";
+import type { CommercetoolsCartIdentifier} from "../schema/commercetools.schema";
+import { CommercetoolsCartIdentifierSchema, CommercetoolsCartPaymentInstructionIdentifierSchema } from "../schema/commercetools.schema";
+import {  CartPaymentProvider, PaymentMethodIdentifierSchema,  } from "@reactionary/core";
+import type { CartPaymentQueryByCart, CartPaymentMutationAddPayment, CartPaymentMutationCancelPayment, Session, RequestContext , Cache, CartPaymentInstruction, Currency} from "@reactionary/core";
+import type z from "zod";
 
 export class CommercetoolsCartPaymentProvider<
   T extends CartPaymentInstruction = CartPaymentInstruction
@@ -19,11 +21,9 @@ export class CommercetoolsCartPaymentProvider<
     this.config = config;
   }
 
-  protected getClient(session: Session) {
-    const token = session.identity.keyring.find(x => x.service === 'commercetools')?.token;
-    const client = new CommercetoolsClient(this.config).getClient(
-      token
-    );
+  protected async getClient(reqCtx: RequestContext) {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+
     return {
       payments: client.withProjectKey({ projectKey: this.config.projectKey }).me().payments(),
       carts: client.withProjectKey({ projectKey: this.config.projectKey }).me().carts()
@@ -33,8 +33,8 @@ export class CommercetoolsCartPaymentProvider<
 
 
   @traced()
-  public override async getByCartIdentifier(payload: CartPaymentQueryByCart, session: Session): Promise<T[]> {
-    const client = this.getClient(session);
+  public override async getByCartIdentifier(payload: CartPaymentQueryByCart, reqCtx: RequestContext): Promise<T[]> {
+    const client = await this.getClient(reqCtx);
 
     const ctId = payload.cart as CommercetoolsCartIdentifier;
     const ctVersion = ctId.version || 0;
@@ -53,7 +53,7 @@ export class CommercetoolsCartPaymentProvider<
       }
 
       // Map over the payments and parse each one
-      const parsedPayments = payments.map(payment => this.parseSingle(payment, session));
+      const parsedPayments = payments.map(payment => this.parseSingle(payment, reqCtx));
 
       // Commercetools does not link carts to payments, but the other way around, so for this we have to synthesize the link.
       const returnPayments = parsedPayments.map(x => {
@@ -65,8 +65,8 @@ export class CommercetoolsCartPaymentProvider<
 
 
 
-  public override async initiatePaymentForCart(payload: CartPaymentMutationAddPayment, session: Session): Promise<T> {
-    const client = this.getClient(session);
+  public override async initiatePaymentForCart(payload: CartPaymentMutationAddPayment, reqCtx: RequestContext): Promise<T> {
+    const client = await this.getClient(reqCtx);
     const cartId = payload.cart as CommercetoolsCartIdentifier;
     const response = await client.payments.post({
       body: {
@@ -78,19 +78,20 @@ export class CommercetoolsCartPaymentProvider<
         paymentMethodInfo: {
           method: payload.paymentInstruction.paymentMethod.method,
           name: {
-            [session.languageContext.locale]: payload.paymentInstruction.paymentMethod.name
+            [reqCtx.languageContext.locale]: payload.paymentInstruction.paymentMethod.name
           },
           paymentInterface: payload.paymentInstruction.paymentMethod.paymentProcessor
         },
         custom:{
-        type: {
-          typeId: 'type',
-          key: 'reactionaryPaymentCustomFields',
+          type: {
+            typeId: 'type',
+            key: 'reactionaryPaymentCustomFields',
+          },
+          fields: {
+            cartId: cartId.key,
+            cartVersion: cartId.version + '',
+          }
         },
-        fields: {
-          cartId: cartId.key,
-          cartVersion: cartId.version + '',
-        }},
 
       },
     }).execute();
@@ -112,7 +113,7 @@ export class CommercetoolsCartPaymentProvider<
       }
     }).execute();
 
-    const payment = this.parseSingle(response.body, session);
+    const payment = this.parseSingle(response.body, reqCtx);
 
     // we return the newest cart version so caller can update their cart reference, if they want to.
     // hopefully this wont cause excessive confusion
@@ -125,8 +126,8 @@ export class CommercetoolsCartPaymentProvider<
 
 
   @traced()
-  public override async cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, session: Session): Promise<T> {
-    const client = this.getClient(session);
+  public override async cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, reqCtx: RequestContext): Promise<T> {
+    const client = await this.getClient(reqCtx);
 
     // get newest version
     const newestVersion = await client.payments.withId({ ID: payload.paymentInstruction.key }).get().execute();
@@ -153,7 +154,7 @@ export class CommercetoolsCartPaymentProvider<
       }
     }).execute();
 
-    const payment = this.parseSingle(response.body, session);
+    const payment = this.parseSingle(response.body, reqCtx);
     payment.cart = payload.cart;
     return payment;
   }
@@ -161,7 +162,7 @@ export class CommercetoolsCartPaymentProvider<
 
 
   @traced()
-  protected override parseSingle(_body: unknown, session: Session): T {
+  protected override parseSingle(_body: unknown, reqCtx: RequestContext): T {
     const body = _body as CTPayment;
 
     const base = this.newModel();