@reactionary/source 0.6.1 → 0.6.3

package/packages/algolia/src/core/initialize.ts

@@ -0,0 +1,82 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import { AlgoliaProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { AlgoliaCapabilities } from '../schema/capabilities.schema.js';
+import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
+import { AlgoliaAnalyticsCapability } from '../capabilities/analytics.capability.js';
+import { AlgoliaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import { AlgoliaProductSearchResultSchema } from '../schema/search.schema.js';
+import {
+  type AlgoliaClientFromCapabilities,
+  resolveCapabilityWithFactory,
+  resolveDirectCapability,
+} from './initialize.types.js';
+
+export function withAlgoliaCapabilities<T extends AlgoliaCapabilities>(
+  configuration: AlgoliaConfiguration,
+  capabilities: T,
+) {
+  return (
+    cache: Cache,
+    context: RequestContext,
+  ): AlgoliaClientFromCapabilities<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client: any = {};
+
+    if (capabilities.productSearch?.enabled) {
+      const defaultFactory = new AlgoliaProductSearchFactory(
+        AlgoliaProductSearchResultSchema,
+      );
+      client.productSearch = resolveCapabilityWithFactory(
+        capabilities.productSearch,
+        {
+          factory: defaultFactory,
+          capability: (args) =>
+            new AlgoliaProductSearchCapability(
+              args.cache,
+              args.context,
+              args.config,
+              args.factory,
+            ),
+        },
+        (factory) => ({
+          cache,
+          context,
+          config: configuration,
+          factory,
+        }),
+      );
+    }
+
+    if (capabilities.analytics?.enabled) {
+      client.analytics = resolveDirectCapability(
+        capabilities.analytics,
+        (args) => new AlgoliaAnalyticsCapability(args.cache, args.context, args.config),
+        {
+          cache,
+          context,
+          config: configuration,
+        },
+      );
+    }
+
+    if (capabilities.productRecommendations?.enabled) {
+      client.productRecommendations = resolveDirectCapability(
+        capabilities.productRecommendations,
+        (args) =>
+          new AlgoliaProductRecommendationsCapability(
+            args.config,
+            args.cache,
+            args.context,
+          ),
+        {
+          cache,
+          context,
+          config: configuration,
+        },
+      );
+    }
+
+    return client;
+  };
+}

package/packages/algolia/src/core/initialize.types.ts

@@ -0,0 +1,107 @@
+import type {
+  ClientFromCapabilities,
+  ProductSearchFactory,
+} from '@reactionary/core';
+import type { AlgoliaCapabilities } from '../schema/capabilities.schema.js';
+import type { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { AlgoliaAnalyticsCapability } from '../capabilities/analytics.capability.js';
+import type { AlgoliaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import type { AlgoliaProductSearchCapability } from '../capabilities/product-search.capability.js';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends AlgoliaCapabilities> =
+  Omit<T, 'productSearch' | 'analytics' | 'productRecommendations'> & {
+    productSearch?: EnabledCapability<T['productSearch']>;
+    analytics?: EnabledCapability<T['analytics']>;
+    productRecommendations?: EnabledCapability<T['productRecommendations']>;
+  };
+
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
+  TCapability extends { enabled: true; factory?: infer TFactory }
+    ? TFactory extends TContract
+      ? TFactory
+      : TDefaultFactory
+    : TDefaultFactory;
+
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> =
+  TCapability extends { enabled: true; capability?: infer TCapabilityFactory }
+    ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability
+      ? TResolvedCapability
+      : TDefaultCapability
+    : TDefaultCapability;
+
+type CapabilityOverride<
+  TCapability,
+  TKey extends string,
+  TResolvedCapability,
+> = TCapability extends { enabled: true }
+  ? { [K in TKey]: TResolvedCapability }
+  : Record<never, never>;
+
+type ProductSearchFactoryFor<T extends AlgoliaCapabilities> =
+  ExtractCapabilityFactory<
+    T['productSearch'],
+    ProductSearchFactory,
+    AlgoliaProductSearchFactory
+  >;
+
+type ProductSearchCapabilityFor<T extends AlgoliaCapabilities> =
+  ExtractCapabilityImplementation<
+    T['productSearch'],
+    AlgoliaProductSearchCapability<ProductSearchFactoryFor<T>>
+  >;
+
+type AnalyticsCapabilityFor<T extends AlgoliaCapabilities> =
+  ExtractCapabilityImplementation<T['analytics'], AlgoliaAnalyticsCapability>;
+
+type ProductRecommendationsCapabilityFor<T extends AlgoliaCapabilities> =
+  ExtractCapabilityImplementation<
+    T['productRecommendations'],
+    AlgoliaProductRecommendationsCapability
+  >;
+
+export type AlgoliaClientFromCapabilities<T extends AlgoliaCapabilities> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  'productSearch' | 'analytics' | 'productRecommendations'
+> &
+  CapabilityOverride<T['productSearch'], 'productSearch', ProductSearchCapabilityFor<T>> &
+  CapabilityOverride<T['analytics'], 'analytics', AnalyticsCapabilityFor<T>> &
+  CapabilityOverride<
+    T['productRecommendations'],
+    'productRecommendations',
+    ProductRecommendationsCapabilityFor<T>
+  >;
+
+export function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(
+  capability:
+    | {
+        factory?: TFactory;
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
+      }
+    | undefined,
+  defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+  },
+  buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs,
+): TResolvedCapability {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+
+export function resolveDirectCapability<TResolvedCapability, TCapabilityArgs>(
+  capability:
+    | {
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
+      }
+    | undefined,
+  defaultCapability: (args: TCapabilityArgs) => TResolvedCapability,
+  args: TCapabilityArgs,
+): TResolvedCapability {
+  const capabilityFactory = capability?.capability ?? defaultCapability;
+  return capabilityFactory(args);
+}

package/packages/algolia/src/factories/index.ts

@@ -0,0 +1 @@
+export * from './product-search/product-search.factory.js';

package/packages/algolia/src/factories/product-search/product-search.factory.ts

@@ -0,0 +1,182 @@
+import type {
+  AnyProductSearchResultSchema,
+  FacetIdentifier,
+  FacetValueIdentifier,
+  ProductSearchFactory,
+  ProductSearchQueryByTerm,
+  ProductSearchResultFacet,
+  ProductSearchResultFacetValue,
+  ProductSearchResultItem,
+  ProductSearchResultItemVariant,
+  RequestContext,
+} from '@reactionary/core';
+import {
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductSearchResultFacetSchema,
+  ProductSearchResultFacetValueSchema,
+  ProductSearchResultItemVariantSchema,
+} from '@reactionary/core';
+import type * as z from 'zod';
+import type { SearchResponse } from 'algoliasearch';
+import type {
+  AlgoliaNativeRecord,
+  AlgoliaNativeVariant,
+  AlgoliaProductSearchResult,
+} from '../../schema/search.schema.js';
+import type { AlgoliaProductSearchResultSchema } from '../../schema/search.schema.js';
+
+export class AlgoliaProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof AlgoliaProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    const body = this.parseInput(data);
+    const items = body.hits.map((hit) => this.parseSingle(hit));
+
+    let facets: ProductSearchResultFacet[] = [];
+    for (const id in body.facets) {
+      const values = body.facets[id];
+      const facetId = FacetIdentifierSchema.parse({ key: id });
+      facets.push(this.parseFacet(facetId, values));
+    }
+
+    const selectedCategoryFacet =
+      query.search.facets.find((x) => x.facet.key === 'categories') ||
+      query.search.categoryFilter;
+
+    let subCategoryFacet;
+    if (selectedCategoryFacet) {
+      const valueDepth = selectedCategoryFacet.key.split(' > ').length;
+      subCategoryFacet = facets.find(
+        (f) => f.identifier.key === `hierarchy.lvl${valueDepth}`,
+      );
+    } else {
+      subCategoryFacet = facets.find((f) => f.identifier.key === 'hierarchy.lvl0');
+    }
+
+    if (subCategoryFacet) {
+      subCategoryFacet.identifier = FacetIdentifierSchema.parse({ key: 'categories' });
+      subCategoryFacet.name = 'Categories';
+      for (const value of subCategoryFacet.values) {
+        const pathParts = value.identifier.key.split(' > ');
+        value.identifier.facet = subCategoryFacet.identifier;
+        value.name = pathParts[pathParts.length - 1];
+      }
+    }
+
+    facets = facets.filter((f) => !f.identifier.key.startsWith('hierarchy.lvl'));
+
+    const result = {
+      identifier: {
+        term: query.search.term,
+        facets: query.search.facets,
+        filters: query.search.filters,
+        paginationOptions: query.search.paginationOptions,
+        index: body.index || '',
+        key: body.queryID || '',
+      },
+      pageNumber: (body.page || 0) + 1,
+      pageSize: body.hitsPerPage || 0,
+      totalCount: body.nbHits || 0,
+      totalPages: body.nbPages || 0,
+      items,
+      facets,
+    } satisfies AlgoliaProductSearchResult;
+
+    return this.productSearchResultSchema.parse(result);
+  }
+
+  protected parseSingle(body: AlgoliaNativeRecord): ProductSearchResultItem {
+    return {
+      identifier: { key: body.objectID },
+      name: body.name || body.objectID,
+      slug: body.slug || body.objectID,
+      variants: [...(body.variants || [])].map((variant) =>
+        this.parseVariant(variant, body),
+      ),
+    } satisfies ProductSearchResultItem;
+  }
+
+  protected parseVariant(
+    variant: AlgoliaNativeVariant,
+    product: AlgoliaNativeRecord,
+  ): ProductSearchResultItemVariant {
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: {
+        sku: variant.sku,
+      },
+      image: ImageSchema.parse({
+        sourceUrl: variant.image,
+        altText: product.name || '',
+      }),
+    } satisfies Partial<ProductSearchResultItemVariant>);
+  }
+
+  protected parseFacet(
+    facetIdentifier: FacetIdentifier,
+    facetValues: Record<string, number>,
+  ): ProductSearchResultFacet {
+    const result = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facetIdentifier.key,
+      values: [],
+    } satisfies Partial<ProductSearchResultFacet>);
+
+    for (const valueId in facetValues) {
+      const count = facetValues[valueId];
+      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+        facet: facetIdentifier,
+        key: valueId,
+      } satisfies Partial<FacetValueIdentifier>);
+
+      result.values.push(this.parseFacetValue(facetValueIdentifier, valueId, count));
+    }
+
+    return result;
+  }
+
+  protected parseFacetValue(
+    facetValueIdentifier: FacetValueIdentifier,
+    label: string,
+    count: number,
+  ): ProductSearchResultFacetValue {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count,
+      active: false,
+    } satisfies Partial<ProductSearchResultFacetValue>);
+  }
+
+  protected parseInput(data: unknown): SearchResponse<AlgoliaNativeRecord> {
+    if (!this.isSearchResponse(data)) {
+      throw new Error('Invalid Algolia search response');
+    }
+
+    return data;
+  }
+
+  protected isSearchResponse(data: unknown): data is SearchResponse<AlgoliaNativeRecord> {
+    if (!data || typeof data !== 'object') {
+      return false;
+    }
+
+    if (!('hits' in data) || !Array.isArray(data.hits)) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/{providers/fake → packages/algolia}/src/index.ts

@@ -1,5 +1,6 @@
 export * from './core/initialize.js';
+export * from './capabilities/index.js';
+export * from './factories/index.js';
 
-export * from './providers/index.js'
-export * from './schema/capabilities.schema.js';
 export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';

package/packages/algolia/src/schema/capabilities.schema.ts

@@ -0,0 +1,84 @@
+import type {
+  AnalyticsCapability,
+  Cache,
+  ProductRecommendationsCapability,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchCapability,
+  RequestContext,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { AlgoliaConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+
+const ProductSearchCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional(),
+});
+
+const CapabilityOverrideSchema = z.looseObject({
+  enabled: z.boolean(),
+  capability: z.unknown().optional(),
+});
+
+export const AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
+  productSearch: true,
+  analytics: true,
+  productRecommendations: true,
+})
+  .extend({
+    productSearch: ProductSearchCapabilitySchema.optional(),
+    analytics: CapabilityOverrideSchema.optional(),
+    productRecommendations: CapabilityOverrideSchema.optional(),
+  })
+  .partial();
+
+export interface AlgoliaCapabilityFactoryArgs {
+  cache: Cache;
+  context: RequestContext;
+  config: AlgoliaConfiguration;
+}
+
+export interface AlgoliaProductSearchCapabilityFactoryArgs<
+  TFactory extends ProductSearchFactory = ProductSearchFactory,
+> extends AlgoliaCapabilityFactoryArgs {
+  factory: ProductSearchFactoryWithOutput<TFactory>;
+}
+
+export interface AlgoliaProductSearchCapabilityConfig<
+  TFactory extends ProductSearchFactory = ProductSearchFactory,
+  TCapability extends ProductSearchCapability = ProductSearchCapability,
+> {
+  enabled: boolean;
+  factory?: ProductSearchFactoryWithOutput<TFactory>;
+  capability?: (args: AlgoliaProductSearchCapabilityFactoryArgs<TFactory>) => TCapability;
+}
+
+export interface AlgoliaAnalyticsCapabilityConfig<
+  TCapability extends AnalyticsCapability = AnalyticsCapability,
+> {
+  enabled: boolean;
+  capability?: (args: AlgoliaCapabilityFactoryArgs) => TCapability;
+}
+
+export interface AlgoliaProductRecommendationsCapabilityConfig<
+  TCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
+> {
+  enabled: boolean;
+  capability?: (args: AlgoliaCapabilityFactoryArgs) => TCapability;
+}
+
+export type AlgoliaCapabilities<
+  TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory,
+  TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability,
+  TAnalyticsCapability extends AnalyticsCapability = AnalyticsCapability,
+  TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
+> = {
+  productSearch?: AlgoliaProductSearchCapabilityConfig<
+    TProductSearchFactory,
+    TProductSearchCapability
+  >;
+  analytics?: AlgoliaAnalyticsCapabilityConfig<TAnalyticsCapability>;
+  productRecommendations?: AlgoliaProductRecommendationsCapabilityConfig<TProductRecommendationsCapability>;
+};

package/{providers → packages}/algolia/src/test/analytics.spec.ts

@@ -1,8 +1,10 @@
 import { describe, it, assert } from 'vitest';
-import { AlgoliaAnalyticsProvider } from '../providers/analytics.provider.js';
+import { AlgoliaAnalyticsCapability } from '../capabilities/analytics.capability.js';
 import { createInitialRequestContext, NoOpCache } from '@reactionary/core';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
-import { AlgoliaProductSearchProvider } from '../providers/product-search.provider.js';
+import { AlgoliaProductSearchCapability } from '../capabilities/product-search.capability.js';
+import { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import { AlgoliaProductSearchResultSchema } from '../schema/search.schema.js';
 
 describe('Analytics event tracking', async () => {
   const config = {
@@ -13,8 +15,14 @@ describe('Analytics event tracking', async () => {
   const cache = new NoOpCache();
   const context = createInitialRequestContext();
 
-  const search = new AlgoliaProductSearchProvider(cache, context, config);
-  const analytics = new AlgoliaAnalyticsProvider(cache, context, config);
+  const searchFactory = new AlgoliaProductSearchFactory(AlgoliaProductSearchResultSchema);
+  const search = new AlgoliaProductSearchCapability<typeof searchFactory>(
+    cache,
+    context,
+    config,
+    searchFactory,
+  );
+  const analytics = new AlgoliaAnalyticsCapability(cache, context, config);
   const searchResult = await search.queryByTerm({
     search: {
       facets: [],

package/packages/algolia/src/test/client-builder-product-search-extension.example.ts

@@ -0,0 +1,85 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  createInitialRequestContext,
+  type ProductSearchQueryByTerm,
+  type RequestContext,
+} from '@reactionary/core';
+import * as z from 'zod';
+import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
+import { withAlgoliaCapabilities } from '../core/initialize.js';
+import { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import { AlgoliaProductSearchResultSchema } from '../schema/search.schema.js';
+
+const assertType = <T>(_value: T) => {
+  void _value;
+};
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+const assertNotAny = <T>(_value: IsAny<T> extends true ? never : T) => {
+  void _value;
+};
+
+const ExtendedProductSearchResultSchema = AlgoliaProductSearchResultSchema.safeExtend(
+  {
+    extendedMeta: z.string(),
+  },
+);
+
+class ExtendedAlgoliaProductSearchFactory extends AlgoliaProductSearchFactory<
+  typeof ExtendedProductSearchResultSchema
+> {
+  constructor() {
+    super(ExtendedProductSearchResultSchema);
+  }
+
+  public override parseSearchResult(
+    context: RequestContext,
+    data: unknown,
+    query: ProductSearchQueryByTerm,
+  ) {
+    const base = super.parseSearchResult(context, data, query);
+    return this.productSearchResultSchema.parse({
+      ...base,
+      extendedMeta: 'from-factory',
+    });
+  }
+}
+
+const config = {
+  appId: 'ALGOLIA_APP_ID',
+  apiKey: 'ALGOLIA_API_KEY',
+  indexName: 'ALGOLIA_INDEX',
+} satisfies AlgoliaConfiguration;
+
+const client = new ClientBuilder(createInitialRequestContext())
+  .withCache(new NoOpCache())
+  .withCapability(
+    withAlgoliaCapabilities(config, {
+      productSearch: {
+        enabled: true,
+        factory: new ExtendedAlgoliaProductSearchFactory(),
+      },
+    }),
+  )
+  .build();
+
+client.productSearch
+  .queryByTerm({
+    search: {
+      term: 'test',
+      facets: [],
+      filters: [],
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 10,
+      },
+    },
+  })
+  .then((result) => {
+    assertNotAny(result);
+    if (result.success) {
+      assertNotAny(result.value);
+      assertNotAny(result.value.extendedMeta);
+      assertType<string>(result.value.extendedMeta);
+    }
+  });

package/packages/algolia/vite.config.ts

@@ -0,0 +1,26 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: import.meta.dirname,
+  cacheDir: '../../node_modules/.vite/packages/algolia',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  test: {
+    name: 'algolia',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/algolia',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/algolia/vitest.config.mts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/algolia',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'algolia',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/algolia',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/commercetools/README.md

@@ -0,0 +1,11 @@
+# commercetools
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build commercetools` to build the library.
+
+## Running unit tests
+
+Run `nx test commercetools` to execute the unit tests via [Vitest](https://vitest.dev/).

package/{core → packages/commercetools}/eslint.config.mjs

@@ -1,4 +1,4 @@
-import baseConfig from '../eslint.config.mjs';
+import baseConfig from '../../eslint.config.mjs';
 
 export default [
   ...baseConfig,
@@ -9,7 +9,7 @@ export default [
         'error',
         {
           ignoredFiles: [
-            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
             '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
             '{projectRoot}/vite.config.{js,ts,mjs,mts}',
           ],

package/packages/commercetools/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@reactionary/commercetools",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5",
+    "@reactionary/core": "0.0.1",
+    "zod": "4.1.9",
+    "@commercetools/ts-client": "^4.9.1",
+    "@commercetools/platform-sdk": "^8.25.0",
+    "debug": "^4.4.3"
+  },
+  "sideEffects": false
+}