@reactionary/source 0.6.1 → 0.6.3

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

@@ -0,0 +1,119 @@
+import type {
+  ClientFromCapabilities,
+  OrderSearchFactory,
+  ProductSearchFactory,
+} from '@reactionary/core';
+import type { MeilisearchCapabilities } from '../schema/capabilities.schema.js';
+import type { MeilisearchOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { MeilisearchProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { MeilisearchOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { MeilisearchProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import type { MeilisearchProductSearchCapability } from '../capabilities/product-search.capability.js';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends MeilisearchCapabilities> =
+  Omit<T, 'productSearch' | 'orderSearch' | 'productRecommendations'> & {
+    productSearch?: EnabledCapability<T['productSearch']>;
+    orderSearch?: EnabledCapability<T['orderSearch']>;
+    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 MeilisearchCapabilities> =
+  ExtractCapabilityFactory<
+    T['productSearch'],
+    ProductSearchFactory,
+    MeilisearchProductSearchFactory
+  >;
+
+type OrderSearchFactoryFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityFactory<
+    T['orderSearch'],
+    OrderSearchFactory,
+    MeilisearchOrderSearchFactory
+  >;
+
+type ProductSearchCapabilityFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityImplementation<
+    T['productSearch'],
+    MeilisearchProductSearchCapability<ProductSearchFactoryFor<T>>
+  >;
+
+type OrderSearchCapabilityFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityImplementation<
+    T['orderSearch'],
+    MeilisearchOrderSearchCapability<OrderSearchFactoryFor<T>>
+  >;
+
+type ProductRecommendationsCapabilityFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityImplementation<
+    T['productRecommendations'],
+    MeilisearchProductRecommendationsCapability
+  >;
+
+export type MeilisearchClientFromCapabilities<T extends MeilisearchCapabilities> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  'productSearch' | 'orderSearch' | 'productRecommendations'
+> &
+  CapabilityOverride<T['productSearch'], 'productSearch', ProductSearchCapabilityFor<T>> &
+  CapabilityOverride<T['orderSearch'], 'orderSearch', OrderSearchCapabilityFor<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/meilisearch/src/factories/index.ts

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

package/packages/meilisearch/src/factories/order-search/order-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyOrderSearchResultSchema,
+  OrderSearchFactory,
+  OrderSearchQueryByTerm,
+  OrderSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MeilisearchOrderSearchFactory<
+  TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema,
+> implements OrderSearchFactory<TOrderSearchResultSchema>
+{
+  public readonly orderSearchResultSchema: TOrderSearchResultSchema;
+
+  constructor(orderSearchResultSchema: TOrderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+
+  public parseOrderSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: OrderSearchQueryByTerm,
+  ): z.output<TOrderSearchResultSchema> {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}

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

@@ -0,0 +1,27 @@
+import type {
+  AnyProductSearchResultSchema,
+  ProductSearchFactory,
+  ProductSearchQueryByTerm,
+  ProductSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MeilisearchProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    return this.productSearchResultSchema.parse(data);
+  }
+}

package/packages/meilisearch/src/index.ts

@@ -0,0 +1,9 @@
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './factories/index.js';
+export * from './capabilities/product-search.capability.js';
+export * from './capabilities/product-recommendations.capability.js';
+export * from './capabilities/order-search.capability.js';
+
+export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';

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

@@ -0,0 +1,98 @@
+import type {
+  Cache,
+  OrderSearchFactory,
+  OrderSearchFactoryWithOutput,
+  OrderSearchCapability,
+  ProductRecommendationsCapability,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchCapability,
+  RequestContext,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { MeilisearchConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+
+const SearchCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional(),
+});
+
+const DirectCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  capability: z.unknown().optional(),
+});
+
+export const MeilisearchCapabilitiesSchema = CapabilitiesSchema.pick({
+  productSearch: true,
+  productRecommendations: true,
+  orderSearch: true,
+})
+  .extend({
+    productSearch: SearchCapabilitySchema.optional(),
+    orderSearch: SearchCapabilitySchema.optional(),
+    productRecommendations: DirectCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface MeilisearchCapabilityFactoryArgs {
+  cache: Cache;
+  context: RequestContext;
+  config: MeilisearchConfiguration;
+}
+
+export interface MeilisearchProductSearchCapabilityFactoryArgs<
+  TFactory extends ProductSearchFactory = ProductSearchFactory,
+> extends MeilisearchCapabilityFactoryArgs {
+  factory: ProductSearchFactoryWithOutput<TFactory>;
+}
+
+export interface MeilisearchOrderSearchCapabilityFactoryArgs<
+  TFactory extends OrderSearchFactory = OrderSearchFactory,
+> extends MeilisearchCapabilityFactoryArgs {
+  factory: OrderSearchFactoryWithOutput<TFactory>;
+}
+
+export interface MeilisearchProductSearchCapabilityConfig<
+  TFactory extends ProductSearchFactory = ProductSearchFactory,
+  TCapability extends ProductSearchCapability = ProductSearchCapability,
+> {
+  enabled: boolean;
+  factory?: ProductSearchFactoryWithOutput<TFactory>;
+  capability?: (args: MeilisearchProductSearchCapabilityFactoryArgs<TFactory>) => TCapability;
+}
+
+export interface MeilisearchOrderSearchCapabilityConfig<
+  TFactory extends OrderSearchFactory = OrderSearchFactory,
+  TCapability extends OrderSearchCapability = OrderSearchCapability,
+> {
+  enabled: boolean;
+  factory?: OrderSearchFactoryWithOutput<TFactory>;
+  capability?: (args: MeilisearchOrderSearchCapabilityFactoryArgs<TFactory>) => TCapability;
+}
+
+export interface MeilisearchProductRecommendationsCapabilityConfig<
+  TCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
+> {
+  enabled: boolean;
+  capability?: (args: MeilisearchCapabilityFactoryArgs) => TCapability;
+}
+
+export type MeilisearchCapabilities<
+  TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory,
+  TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability,
+  TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory,
+  TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability,
+  TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
+> = {
+  productSearch?: MeilisearchProductSearchCapabilityConfig<
+    TProductSearchFactory,
+    TProductSearchCapability
+  >;
+  orderSearch?: MeilisearchOrderSearchCapabilityConfig<
+    TOrderSearchFactory,
+    TOrderSearchCapability
+  >;
+  productRecommendations?: MeilisearchProductRecommendationsCapabilityConfig<TProductRecommendationsCapability>;
+};

package/packages/meilisearch/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/packages/meilisearch/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/packages/meilisearch/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/packages/meilisearch/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/meilisearch',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  test: {
+    name: 'meilisearch',
+    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/meilisearch',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/meilisearch/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/meilisearch',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'meilisearch',
+    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/meilisearch',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/tsconfig.base.json

@@ -4,35 +4,27 @@
     "rootDir": ".",
     "sourceMap": true,
     "declaration": false,
-    "moduleResolution": "node",
-    "emitDecoratorMetadata": true,
+    "moduleResolution": "nodenext",
     "experimentalDecorators": true,
     "importHelpers": true,
-    "target": "es2015",
-    "module": "esnext",
-    "lib": ["es2020", "dom"],
+    "target": "es2022",
+    "module": "nodenext",
+    "lib": ["es2022"],
     "skipLibCheck": true,
-    "skipDefaultLibCheck": true,
     "baseUrl": ".",
+    "verbatimModuleSyntax": true,
     "paths": {
-      "@reactionary/core": ["core/src/index.ts"],
       "@reactionary/examples-node": ["examples/node/src/index.ts"],
-      "@reactionary/provider-medusa": ["providers/medusa/src/index.ts"],
-      "@reactionary/otel": ["otel/src/index.ts"],
-      "@reactionary/provider-algolia": ["providers/algolia/src/index.ts"],
-      "@reactionary/provider-meilisearch": [
-        "providers/meilisearch/src/index.ts"
-      ],
-      "@reactionary/provider-commercetools": [
-        "providers/commercetools/src/index.ts"
-      ],
-      "@reactionary/provider-fake": ["providers/fake/src/index.ts"],
-      "@reactionary/provider-posthog": ["providers/posthog/src/index.ts"],
+      "@reactionary/commercetools": ["packages/commercetools/src/index.ts"],
+      "@reactionary/core": ["packages/core/src/index.ts"],
+      "@reactionary/algolia": ["packages/algolia/src/index.ts"],
+      "@reactionary/fake": ["packages/fake/src/index.ts"],
       "@reactionary/google-analytics": [
-        "providers/google-analytics/src/index.ts"
-      ]
+        "packages/google-analytics/src/index.ts"
+      ],
+      "@reactionary/medusa": ["packages/medusa/src/index.ts"],
+      "@reactionary/meilisearch": ["packages/meilisearch/src/index.ts"]
     },
-    "verbatimModuleSyntax": true
   },
   "exclude": ["node_modules", "tmp"]
 }

package/core/project.json

@@ -1,34 +0,0 @@
-{
-  "name": "core",
-  "$schema": "../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "core/src",
-  "projectType": "library",
-  "release": {
-    "version": {
-      "currentVersionResolver": "git-tag",
-      "fallbackCurrentVersionResolver": "disk",
-      "preserveLocalDependencyProtocols": false,
-      "manifestRootsToUpdate": ["dist/{projectRoot}"]
-    }
-  },
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/core",
-        "main": "core/src/index.ts",
-        "tsConfig": "core/tsconfig.lib.json",
-        "assets": ["core/*.md"],
-        "format": ["esm"],
-        "bundle": false
-      }
-    },
-    "nx-release-publish": {
-      "options": {
-        "packageRoot": "dist/{projectRoot}"
-      }
-    }
-  }
-}

package/core/src/client/client-builder.ts

@@ -1,84 +0,0 @@
-import type { Cache } from '../cache/cache.interface.js';
-import { NoOpCache } from '../cache/noop-cache.js';
-import type { Client } from './client.js';
-import { MulticastAnalyticsProvider, type AnalyticsProvider } from '../providers/analytics.provider.js';
-import {
-  RequestContextSchema,
-  type RequestContext,
-} from '../schemas/session.schema.js';
-import { MulticastProductRecommendationsProvider, type ProductRecommendationsProvider } from '../providers/product-recommendations.provider.js';
-
-type CapabilityFactory<T> = (cache: Cache, context: RequestContext) => T;
-
-type MergeCapabilities<Acc, New> = Omit<Acc, keyof New> & New;
-
-export class ClientBuilder<TClient = Client> {
-  private factories: Array<CapabilityFactory<Partial<Client>>> = [];
-  private cache: Cache | undefined;
-  private context: RequestContext;
-
-  constructor(context: RequestContext) {
-    this.context = context;
-  }
-
-  withCapability<TNew extends Partial<Client>>(
-    factory: CapabilityFactory<TNew>
-  ): ClientBuilder<MergeCapabilities<TClient, TNew>> {
-    const newBuilder = new ClientBuilder<MergeCapabilities<TClient, TNew>>(this.context);
-    newBuilder.factories = [...this.factories, factory];
-    newBuilder.cache = this.cache;
-    newBuilder.context = this.context;
-    return newBuilder;
-  }
-
-  withCache(cache: Cache): ClientBuilder<TClient> {
-    const newBuilder = new ClientBuilder<TClient>(this.context);
-    newBuilder.factories = [...this.factories];
-    newBuilder.cache = cache;
-    newBuilder.context = this.context;
-    return newBuilder;
-  }
-
-  build(): TClient & { cache: Cache } {
-    let client = {} as TClient;
-
-    // Default to no-op cache if none is provided
-    const sharedCache = this.cache || new NoOpCache();
-    const validatedContext = RequestContextSchema.safeParse(this.context);
-
-    // Avoid returning the parsed result for context, to preserve object equality at the top level
-    if (!validatedContext.success) {
-      throw new Error('Invalid context: ' + validatedContext.error);
-    }
-
-    const mergedAnalytics: AnalyticsProvider[] = [];
-
-    const mergedProductRecommendationsProviders: ProductRecommendationsProvider[] = [];
-
-    for (const factory of this.factories) {
-      const provider = factory(sharedCache, this.context);
-      client = {
-        ...client,
-        ...provider,
-      };
-
-      if (provider.analytics) {
-        mergedAnalytics.push(provider.analytics);
-      }
-
-      if (provider.productRecommendations) {
-        mergedProductRecommendationsProviders.push(provider.productRecommendations);
-      }
-    }
-
-    // Add cache to complete the client
-    const completeClient = {
-      ...client,
-      analytics: new MulticastAnalyticsProvider(sharedCache, this.context, mergedAnalytics),
-      productRecommendations: new MulticastProductRecommendationsProvider(sharedCache, this.context, mergedProductRecommendationsProviders),
-      cache: sharedCache,
-    } as TClient & { cache: Cache };
-
-    return completeClient;
-  }
-}

package/core/src/client/client.ts

@@ -1,35 +0,0 @@
-import type { ProductProvider } from "../providers/product.provider.js";
-import type { ProductSearchProvider } from "../providers/product-search.provider.js";
-import type { IdentityProvider } from '../providers/identity.provider.js';
-import type { CartProvider } from "../providers/cart.provider.js";
-import type { PriceProvider } from "../providers/price.provider.js";
-import type { InventoryProvider } from "../providers/inventory.provider.js";
-import type { Cache } from "../cache/cache.interface.js";
-import type { CategoryProvider } from "../providers/category.provider.js";
-import type { AnalyticsProvider, CheckoutProvider, OrderProvider, ProductListProvider, ProfileProvider, StoreProvider } from "../providers/index.js";
-import type { OrderSearchProvider } from "../providers/order-search.provider.js";
-import type { ProductRecommendationsProvider } from "../providers/product-recommendations.provider.js";
-import type { ProductAssociationsProvider } from "../providers/product-associations.provider.js";
-import type { ProductReviewsProvider } from "../providers/product-reviews.provider.js";
-
-export interface Client {
-    product: ProductProvider,
-    productSearch: ProductSearchProvider,
-    productRecommendations: ProductRecommendationsProvider,
-    productAssociations: ProductAssociationsProvider,
-    productReviews: ProductReviewsProvider,
-    productList: ProductListProvider,
-    identity: IdentityProvider,
-    cache: Cache,
-    cart: CartProvider,
-    checkout: CheckoutProvider,
-    analytics: AnalyticsProvider,
-    price: PriceProvider,
-    inventory: InventoryProvider,
-    category: CategoryProvider,
-    profile: ProfileProvider,
-    store: StoreProvider,
-    order: OrderProvider,
-    orderSearch: OrderSearchProvider,
-}
-

package/core/src/index.ts

@@ -1,6 +0,0 @@
-export * from './cache/index.js';
-export * from './client/index.js';
-export * from './decorators/index.js';
-export * from './providers/index.js';
-export * from './schemas/index.js';
-export * from './initialization.js';

package/core/src/providers/index.ts

@@ -1,18 +0,0 @@
-export * from './analytics.provider.js';
-export * from './base.provider.js';
-export * from './cart.provider.js';
-export * from './category.provider.js';
-export * from './checkout.provider.js';
-export * from './identity.provider.js';
-export * from './inventory.provider.js';
-export * from './price.provider.js';
-export * from './product.provider.js';
-export * from './profile.provider.js';
-export * from './product-search.provider.js';
-export * from './product-recommendations.provider.js';
-export * from './product-associations.provider.js';
-export * from './product-reviews.provider.js';
-export * from './product-list.provider.js'
-export * from './store.provider.js';
-export * from './order.provider.js'
-export * from './order-search.provider.js'