@reactionary/source 0.0.52 → 0.2.15

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,
     });

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

@@ -1,88 +1,144 @@
-import type {
-    Cache,
-    ProductProvider,
-    SearchProvider,
-    IdentityProvider,
-    CartProvider,
-    InventoryProvider,
-    PriceProvider,
-    CategoryProvider,
-    StoreProvider,
-    CheckoutProvider,
-    OrderProvider
-    } from "@reactionary/core";
+import type { Cache, RequestContext, Client, ClientFromCapabilities } from '@reactionary/core';
 import {
-    CartSchema,
-    IdentitySchema,
-    InventorySchema,
-    PriceSchema,
-    ProductSchema,
-    SearchResultSchema,
-    CategorySchema,
-    CheckoutSchema
-} from "@reactionary/core";
-import type { CommercetoolsCapabilities } from "../schema/capabilities.schema.js";
-import { CommercetoolsSearchProvider } from "../providers/search.provider.js";
+  CommercetoolsCapabilitiesSchema,
+  type CommercetoolsCapabilities,
+} from '../schema/capabilities.schema.js';
+import { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
 import { CommercetoolsProductProvider } from '../providers/product.provider.js';
-import type { CommercetoolsConfiguration } from "../schema/configuration.schema.js";
-import { CommercetoolsIdentityProvider } from "../providers/identity.provider.js";
-import { CommercetoolsCartProvider } from "../providers/cart.provider.js";
-import { CommercetoolsInventoryProvider } from "../providers/inventory.provider.js";
-import { CommercetoolsPriceProvider } from "../providers/price.provider.js";
-import { CommercetoolsCategoryProvider } from "../providers/category.provider.js";
-import { CommercetoolsCheckoutProvider } from "../providers/index.js";
+import {
+  CommercetoolsConfigurationSchema,
+  type CommercetoolsConfiguration,
+} from '../schema/configuration.schema.js';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
+import { CommercetoolsCartProvider } from '../providers/cart.provider.js';
+import { CommercetoolsInventoryProvider } from '../providers/inventory.provider.js';
+import { CommercetoolsPriceProvider } from '../providers/price.provider.js';
+import { CommercetoolsCategoryProvider } from '../providers/category.provider.js';
+import {
+  CommercetoolsCheckoutProvider,
+  CommercetoolsOrderProvider,
+  CommercetoolsOrderSearchProvider,
+  CommercetoolsProfileProvider,
+  CommercetoolsStoreProvider,
+} from '../providers/index.js';
+import { CommercetoolsAPI } from './client.js';
+
+export function withCommercetoolsCapabilities<
+  T extends CommercetoolsCapabilities
+>(configuration: CommercetoolsConfiguration, capabilities: T) {
+  return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
+    const client: any = {};
+    const config = CommercetoolsConfigurationSchema.parse(configuration);
+    const caps = CommercetoolsCapabilitiesSchema.parse(capabilities);
+    const commercetoolsApi = new CommercetoolsAPI(config, context);
+
+    if (caps.product) {
+      client.product = new CommercetoolsProductProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-type CommercetoolsClient<T extends CommercetoolsCapabilities> =
-    (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['price'] extends true ? { price: PriceProvider } : object) &
-    (T['store'] extends true ? { store: StoreProvider } : object) &
-    (T['order'] extends true ? { order: OrderProvider } : object) &
-    (T['checkout'] extends true ? { checkout: CheckoutProvider } : object) ;
-export function withCommercetoolsCapabilities<T extends CommercetoolsCapabilities>(
-    configuration: CommercetoolsConfiguration,
-    capabilities: T
-) {
-    return (cache: Cache): CommercetoolsClient<T> => {
-        const client: any = {};
+    if (caps.profile) {
+      client.profile = new CommercetoolsProfileProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.product) {
-            client.product = new CommercetoolsProductProvider(configuration, ProductSchema, cache);
-        }
+    if (caps.productSearch) {
+      client.productSearch = new CommercetoolsSearchProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.search) {
-            client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, cache);
-        }
+    if (caps.identity) {
+      client.identity = new CommercetoolsIdentityProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.identity) {
-            client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, cache);
-        }
+    if (caps.cart) {
+      client.cart = new CommercetoolsCartProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.cart) {
-            client.cart = new CommercetoolsCartProvider(configuration, CartSchema, cache);
-        }
+    if (caps.inventory) {
+      client.inventory = new CommercetoolsInventoryProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.inventory) {
-            client.inventory = new CommercetoolsInventoryProvider(configuration, InventorySchema, cache);
-        }
+    if (caps.price) {
+      client.price = new CommercetoolsPriceProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.price) {
-            client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, cache);
-        }
+    if (caps.category) {
+      client.category = new CommercetoolsCategoryProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.category) {
-            client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
-        }
+    if (caps.checkout) {
+      client.checkout = new CommercetoolsCheckoutProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        if (capabilities.checkout) {
-          client.checkout = new CommercetoolsCheckoutProvider(configuration, CheckoutSchema, cache);
-        }
+    if (caps.store) {
+        client.store = new CommercetoolsStoreProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
+    if (caps.order) {
+        client.store = new CommercetoolsOrderProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
+    if (caps.orderSearch) {
+        client.orderSearch = new CommercetoolsOrderSearchProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
 
-        return client;
-    };
+    return client;
+  };
 }

package/providers/commercetools/src/core/token-cache.ts

@@ -0,0 +1,45 @@
+import type { TokenCache, TokenCacheOptions, TokenStore } from "@commercetools/ts-client";
+import type { RequestContext } from "@reactionary/core";
+import { CommercetoolsSessionSchema } from "../schema/session.schema.js";
+
+export const PROVIDER_COMMERCETOOLS_SESSION_KEY = 'PROVIDER_COMMERCETOOLS';
+export class RequestContextTokenCache implements TokenCache {
+  constructor(protected context: RequestContext) {}
+
+  public async get(
+    tokenCacheOptions?: TokenCacheOptions
+  ): Promise<TokenStore | undefined> {
+    const session = CommercetoolsSessionSchema.parse(
+      this.context.session[PROVIDER_COMMERCETOOLS_SESSION_KEY] || {}
+    );
+
+    if (!session) {
+      return {
+        refreshToken: undefined,
+        token: '',
+        expirationTime: new Date().getTime(),
+      };
+    }
+
+    return {
+      refreshToken: session.refreshToken,
+      token: session.token,
+      expirationTime: session.expirationTime,
+    };
+  }
+
+  public async set(
+    cache: TokenStore,
+    tokenCacheOptions?: TokenCacheOptions
+  ): Promise<void> {
+    const session = CommercetoolsSessionSchema.parse(
+      this.context.session[PROVIDER_COMMERCETOOLS_SESSION_KEY] || {}
+    );
+
+    this.context.session[PROVIDER_COMMERCETOOLS_SESSION_KEY] = session;
+
+    session.refreshToken = cache.refreshToken;
+    session.token = cache.token;
+    session.expirationTime = cache.expirationTime;
+  }
+}

package/providers/commercetools/src/index.ts

@@ -4,9 +4,10 @@ export * from './core/initialize.js';
 export * from './providers/cart.provider.js';
 export * from './providers/identity.provider.js';
 export * from './providers/inventory.provider.js';
+export * from './providers/order-search.provider.js';
 export * from './providers/price.provider.js';
 export * from './providers/product.provider.js';
-export * from './providers/search.provider.js';
+export * from './providers/product-search.provider.js';
 
 export * from './schema/capabilities.schema.js';
-export * from './schema/configuration.schema.js';
+export * from './schema/configuration.schema.js';