@reactionary/source 0.0.51 → 0.2.15

package/providers/commercetools/src/test/product.provider.spec.ts

@@ -1,80 +0,0 @@
-import 'dotenv/config';
-import type { RequestContext} from '@reactionary/core';
-import { NoOpCache, ProductSchema, Session, createInitialRequestContext } from '@reactionary/core';
-import { CommercetoolsProductProvider } from '../providers/product.provider';
-import {  getCommercetoolsTestConfiguration } from './test-utils';
-
-const testData = {
-  product : {
-    id: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
-    name: 'Sunnai Glass Bowl',
-    image: 'https://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg',
-    sku: 'SGB-01',
-
-  },
-
-}
-
-describe('Commercetools Product Provider', () => {
-
-    let provider: CommercetoolsProductProvider;
-    let reqCtx: RequestContext;
-
-    beforeAll( () => {
-      provider = new CommercetoolsProductProvider(getCommercetoolsTestConfiguration(), ProductSchema, new NoOpCache());
-    });
-
-    beforeEach( () => {
-      reqCtx = createInitialRequestContext()
-    })
-
-
-  it('should be able to get a product by id', async () => {
-    const result = await provider.getById( { id: testData.product.id }, reqCtx);
-
-    expect(result).toBeTruthy();
-    expect(result.identifier.key).toBe(testData.product.id);
-    expect(result.meta.placeholder).toBe(false);
-    expect(result.name).toBe(testData.product.name);
-    expect(result.image).toBe(testData.product.image);
-  });
-
-  it('should be able to get a product by slug', async () => {
-    const result = await provider.getBySlug( { slug: 'sunnai-glass-bowl' }, reqCtx);
-
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.meta.placeholder).toBe(false);
-      expect(result.identifier.key).toBe(testData.product.id);
-      expect(result.name).toBe(testData.product.name);
-      expect(result.image).toBe(testData.product.image);
-    }
-  });
-
-  it('should be able to get a product by sku', async () => {
-    const result = await provider.getBySKU( { sku: { key: testData.product.sku } }, reqCtx);
-
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.meta.placeholder).toBe(false);
-      expect(result.identifier.key).toBe(testData.product.id);
-      expect(result.name).toBe(testData.product.name);
-      expect(result.image).toBe(testData.product.image);
-    }
-  });
-
-  it('should return null for unknown slug', async () => {
-    const result = await provider.getBySlug( { slug: 'unknown-slug' }, reqCtx);
-
-    expect(result).toBeNull();
-  });
-
-
-
-  it('should return a placeholder product for unknown id', async () => {
-    const result = await provider.getById( { id: 'unknown-id' }, reqCtx);
-
-    expect(result).toBeTruthy();
-    expect(result.meta.placeholder).toBe(true);
-  });
-});

package/providers/commercetools/src/test/profile.provider.spec.ts

@@ -1,49 +0,0 @@
-import 'dotenv/config';
-import type { RequestContext } from '@reactionary/core';
-import {
-  IdentitySchema,
-  NoOpCache,
-  ProfileSchema,
-  createInitialRequestContext,
-} from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsProfileProvider } from '../providers/profile.provider';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
-
-describe('Commercetools Profile Provider', () => {
-  let provider: CommercetoolsProfileProvider;
-  let identityProvider: CommercetoolsIdentityProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll(() => {
-    provider = new CommercetoolsProfileProvider(
-      getCommercetoolsTestConfiguration(),
-      ProfileSchema,
-      new NoOpCache()
-    );
-
-    identityProvider = new CommercetoolsIdentityProvider(
-      getCommercetoolsTestConfiguration(),
-      IdentitySchema,
-      new NoOpCache()
-    );
-  });
-
-  beforeEach(async () => {
-    reqCtx = createInitialRequestContext();
-
-    const time = new Date().getTime();
-
-    await identityProvider.register({
-        username: `martin.rogne+test-${ time }@solteq.com`,
-        password: 'love2test'
-    }, reqCtx);
-  });
-
-  it('should be able to fetch the profile for the current user', async () => {
-    const profile = await provider.getSelf({}, reqCtx);
-
-    expect(profile).toBeDefined();
-    expect(profile.email).toContain('martin.rogne');
-  });
-});

package/providers/commercetools/src/test/search.provider.spec.ts

@@ -1,61 +0,0 @@
-import 'dotenv/config';
-import type { RequestContext} from '@reactionary/core';
-import { NoOpCache, SearchResultSchema, createInitialRequestContext } from '@reactionary/core';
-import { CommercetoolsSearchProvider } from '../providers/search.provider';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-
-const testData = {
-  searchTerm: 'bowl'
-}
-
-describe('Commercetools Search Provider', () => {
-
-  let provider: CommercetoolsSearchProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll( () => {
-    provider = new CommercetoolsSearchProvider(getCommercetoolsTestConfiguration(), SearchResultSchema, new NoOpCache());
-  });
-
-  beforeEach( () => {
-    reqCtx = createInitialRequestContext()
-  })
-
-  it('should be able to get a result by term', async () => {
-    const result = await provider.queryByTerm( {
-    search: {
-      term: testData.searchTerm,
-      facets: [],
-      page: 1,
-      pageSize: 10,
-    }}, reqCtx);
-
-    expect(result.products.length).toBeGreaterThan(0);
-  });
-
-
-    it('should be able to get a result by term, paged', async () => {
-    const result = await provider.queryByTerm( {
-    search: {
-      term: testData.searchTerm,
-      facets: [],
-      page: 1,
-      pageSize: 1,
-    }}, reqCtx);
-
-    expect(result.products.length).toBeGreaterThan(0);
-    expect(result.pages).toBeGreaterThan(1);
-
-    const result2 = await provider.queryByTerm( {
-    search: {
-      term: testData.searchTerm,
-      facets: [],
-      page: 2,
-      pageSize: 1,
-    }}, reqCtx);
-
-    expect(result2.products.length).toBeGreaterThan(0);
-    expect(result2.pages).toBeGreaterThan(2);
-    expect(result2.products[0].identifier.key).not.toBe(result.products[0].identifier.key);
-  });
-});

package/providers/commercetools/src/test/store.provider.spec.ts

@@ -1,37 +0,0 @@
-import 'dotenv/config';
-import type { RequestContext } from '@reactionary/core';
-import {
-  NoOpCache,
-  StoreSchema,
-  createInitialRequestContext,
-} from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsStoreProvider } from '../providers/store.provider';
-
-describe('Commercetools Store Provider', () => {
-  let provider: CommercetoolsStoreProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll(() => {
-    provider = new CommercetoolsStoreProvider(
-      getCommercetoolsTestConfiguration(),
-      StoreSchema,
-      new NoOpCache()
-    );
-  });
-
-  beforeEach(() => {
-    reqCtx = createInitialRequestContext();
-  });
-
-  it('should be able to query stores by longitude and latitude', async () => {
-    const stores = await provider.queryByProximity({
-        distance: 1000,
-        latitude: 15,
-        longitude: 15,
-        limit: 10
-    }, reqCtx);
-
-    expect(stores.length).toBe(2);
-  });
-});

package/providers/fake/jest.config.ts

@@ -1,10 +0,0 @@
-export default {
-  displayName: 'provider-faker',
-  preset: '../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/providers/fake',
-};

package/providers/fake/src/providers/search.provider.ts

@@ -1,135 +0,0 @@
-import {
-  SearchProvider
-} from '@reactionary/core';
-import type {
-  SearchResult,
-  SearchResultFacet,
-  SearchResultProduct,
-  Cache as ReactionaryCache,
-} from '@reactionary/core';
-import type { RequestContext, SearchQueryByTerm } from '@reactionary/core';
-import type z from 'zod';
-import type { FakeConfiguration } from '../schema/configuration.schema';
-import { Faker, en, base } from '@faker-js/faker';
-import { jitter } from '../utilities/jitter';
-import { traced } from '@reactionary/otel';
-
-export class FakeSearchProvider<
-  T extends SearchResult = SearchResult
-> extends SearchProvider<T> {
-  protected config: FakeConfiguration;
-
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactionaryCache) {
-    super(schema, cache);
-
-    this.config = config;
-  }
-
-  @traced()
-  public override async queryByTerm(
-    payload: SearchQueryByTerm,
-    _reqCtx: RequestContext
-  ): Promise<SearchResult> {
-    await jitter(this.config.jitter.mean, this.config.jitter.deviation);
-
-    const query = payload.search;
-
-    const querySpecificity =
-      20 - query.term.length - query.page - query.facets.length;
-    const totalProducts = 10 * querySpecificity;
-    const totalPages = Math.ceil(totalProducts / query.pageSize);
-    const productsOnPage = Math.min(totalProducts, query.pageSize);
-
-    const productGenerator = new Faker({
-      seed: querySpecificity,
-      locale: [en, base],
-    });
-
-    const facetGenerator = new Faker({
-      seed: 100,
-      locale: [en, base],
-    });
-
-    const products = new Array<SearchResultProduct>();
-    const facets = new Array<SearchResultFacet>();
-
-    for (let i = 0; i < productsOnPage; i++) {
-      products.push({
-        identifier: {
-          key: productGenerator.commerce.isbn(),
-        },
-        image: productGenerator.image.urlPicsumPhotos({
-          height: 300,
-          width: 300,
-          grayscale: true,
-          blur: 8,
-        }),
-        name: productGenerator.commerce.productName(),
-        slug: productGenerator.lorem.slug(),
-      });
-    }
-
-    const facetBase = ['color', 'size'];
-
-    for (const base of facetBase) {
-      const facet: SearchResultFacet = {
-        identifier: {
-          key: base,
-        },
-        name: base,
-        values: [],
-      };
-
-      for (let i = 0; i < 10; i++) {
-        const valueKey = i.toString();
-        const isActive =
-          query.facets.find(
-            (x) => x.facet.key === facet.identifier.key && x.key === valueKey
-          ) !== undefined;
-
-        facet.values.push({
-          active: isActive,
-          count: facetGenerator.number.int({ min: 1, max: 50 }),
-          identifier: {
-            facet: {
-              key: facet.identifier.key,
-            },
-            key: valueKey,
-          },
-          name: facetGenerator.color.human(),
-        });
-      }
-
-      facets.push(facet);
-    }
-
-    const result = {
-      pages: totalPages,
-      identifier: {
-        term: query.term,
-        page: query.page,
-        facets: query.facets,
-        pageSize: query.pageSize,
-      },
-      facets: facets,
-      products: products,
-      meta: {
-        cache: {
-          hit: false,
-          key: '',
-        },
-        placeholder: false,
-      },
-    } satisfies SearchResult;
-
-    const foo = this.childFunction();
-
-    return this.schema.parse(result);
-  }
-
-  @traced()
-  protected childFunction() {
-    const foo = 42;
-    return foo;
-  }
-}

package/trpc/README.md

@@ -1,7 +0,0 @@
-# trpc
-
-This library was generated with [Nx](https://nx.dev).
-
-## Building
-
-Run `nx build trpc` to build the library.

package/trpc/__mocks__/superjson.js

@@ -1,25 +0,0 @@
-// Mock superjson for Jest testing
-module.exports = {
-  default: {
-    stringify: JSON.stringify,
-    parse: JSON.parse,
-    serialize: (obj) => ({ json: obj, meta: undefined }),
-    deserialize: (data) => data.json,
-    output: {
-      serialize: (obj) => ({ json: obj, meta: undefined })
-    },
-    input: {
-      deserialize: (data) => data.json
-    }
-  },
-  stringify: JSON.stringify,
-  parse: JSON.parse,
-  serialize: (obj) => ({ json: obj, meta: undefined }),
-  deserialize: (data) => data.json,
-  output: {
-    serialize: (obj) => ({ json: obj, meta: undefined })
-  },
-  input: {
-    deserialize: (data) => data.json
-  }
-};

package/trpc/jest.config.ts

@@ -1,14 +0,0 @@
-export default {
-  displayName: 'trpc',
-  preset: '../jest.preset.js',
-  testEnvironment: 'node',
-  testTimeout: 15000,
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  moduleNameMapper: {
-    '^superjson$': '<rootDir>/__mocks__/superjson.js',
-  },
-  coverageDirectory: '../coverage/trpc',
-};

package/trpc/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "@reactionary/trpc",
-  "version": "0.0.1",
-  "type": "commonjs",
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "dependencies": {
-    "@trpc/server": "^11.1.2",
-    "@reactionary/core": "0.0.1",
-    "@reactionary/otel": "0.0.1",
-    "superjson": "^2.2.2",
-    "zod": "4.1.9"
-  }
-}

package/trpc/project.json

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

package/trpc/src/client.ts

@@ -1,175 +0,0 @@
-import type { Client, RequestContext} from '@reactionary/core';
-import { Session } from '@reactionary/core';
-import type { TransparentClient } from './types';
-
-/**
- * Configuration options for TRPC client creation
- */
-export interface TRPCClientOptions {
-  /** Default session to use if not provided in method calls */
-  defaultRequestContext?: RequestContext
-  /** Whether to automatically provide request context from defaultRequestContext\ */
-  autoRequestContext?: boolean;
-}
-
-/**
- * Create a type-safe client proxy that uses the original client's type interface
- * while routing all calls through TRPC
- *
- * @example
- * ```typescript
- * import { createTRPCProxyClient } from '@trpc/client';
- * import { createTRPCClient } from '@reactionary/trpc/client';
- *
- * const trpc = createTRPCProxyClient<AppRouter>({
- *   url: 'http://localhost:3000',
- * });
- *
- * // Pass the original client type as the generic parameter
- * const client = createTRPCClient<typeof serverClient>(trpc, {
- *   defaultSession: mySession,
- *   autoSession: true
- * });
- *
- * // Fully typed using the original client interface!
- * const product = await client.product.getById({ id: '123' }, reqCtx);
- * ```
- */
-export function createTRPCClient<TOriginalClient extends Partial<Client>>(
-  trpcClient: any,
-  options: TRPCClientOptions = {}
-): TransparentClient<TOriginalClient> {
-  const { defaultRequestContext, autoRequestContext = false } = options;
-
-  return new Proxy({} as TransparentClient<TOriginalClient>, {
-    get(target, providerName: string | symbol) {
-      if (typeof providerName !== 'string') {
-        return undefined;
-      }
-
-      // Return a typed proxy for the provider that intercepts method calls
-      return new Proxy({}, {
-        get(providerTarget, methodName: string | symbol) {
-          if (typeof methodName !== 'string') {
-            return undefined;
-          }
-
-          // Only expose methods that are marked with TRPC decorators
-          // This eliminates the need to filter TRPC-specific properties
-          return async (payload: any, reqCtxArg?: RequestContext) => {
-            // Determine request context to use
-            let reqCtx = reqCtxArg;
-            if (!reqCtx && autoRequestContext && defaultRequestContext) {
-              reqCtx = defaultRequestContext;
-            }
-
-            // Prepare input for TRPC call
-            const input = {
-              payload,
-              reqCtx
-            };
-
-            // Access TRPC provider and method lazily
-            const trpcProvider = trpcClient[providerName];
-            const trpcMethod = trpcProvider[methodName];
-
-            // Use decorator metadata to determine if this is a query or mutation
-            // Note: We can't directly check the original provider here since we only have
-            // the TRPC client, so we'll fall back to the router's procedure type detection
-            if (trpcMethod?.query) {
-              return await trpcMethod.query(input);
-            } else if (trpcMethod?.mutate) {
-              return await trpcMethod.mutate(input);
-            } else {
-              throw new Error(`Method ${String(providerName)}.${String(methodName)} not found on TRPC client`);
-            }
-          };
-        }
-      });
-    }
-  });
-}
-
-/**
- * Session provider interface for dependency injection
- */
-export interface SessionProvider {
-  getRequestContext(): Promise<RequestContext> | RequestContext;
-}
-
-/**
- * Create a TRPC client with session provider for automatic session management
- *
- * @example
- * ```typescript
- * const sessionProvider: SessionProvider = {
- *   getSession: () => getCurrentUserSession()
- * };
- *
- * const client = createTRPCClientWithSessionProvider(trpc, reqCtxProvider);
- *
- * // Session is automatically provided, fully typed
- * const product = await client.product.getById({ id: '123' });
- * ```
- */
-export function createTRPCClientWithSessionProvider<TOriginalClient extends Partial<Client>>(
-  trpcClient: any,
-  sessionProvider: SessionProvider
-): TransparentClient<TOriginalClient> {
-  return new Proxy({} as TransparentClient<TOriginalClient>, {
-    get(target, providerName: string | symbol) {
-      if (typeof providerName !== 'string') {
-        return undefined;
-      }
-
-      return new Proxy({}, {
-        get(providerTarget, methodName: string | symbol) {
-          if (typeof methodName !== 'string') {
-            return undefined;
-          }
-
-          return async (payload: any, reqCtxArg?: RequestContext) => {
-            // If no session provided, get from provider
-            let reqCtx = reqCtxArg;
-            if (!reqCtx) {
-              reqCtx = await sessionProvider.getRequestContext();
-            }
-
-            const input = {
-              payload,
-              reqCtx
-            };
-
-            // Access TRPC provider and method lazily
-            const trpcProvider = trpcClient[providerName];
-            const trpcMethod = trpcProvider[methodName];
-
-            // Use TRPC client's procedure type detection
-            if (trpcMethod?.query) {
-              return await trpcMethod.query(input);
-            } else if (trpcMethod?.mutate) {
-              return await trpcMethod.mutate(input);
-            } else {
-              throw new Error(`Method ${String(providerName)}.${String(methodName)} not found on TRPC client`);
-            }
-          };
-        }
-      });
-    }
-  });
-}
-
-/**
- * Type alias for creating typed TRPC clients
- * Use the original client type, not the router type
- *
- * @example
- * ```typescript
- * type MyClient = typeof serverClient;
- *
- * function useClient(): MyClient {
- *   return createTRPCClient<MyClient>(trpcProxyClient);
- * }
- * ```
- */
-export type TRPCClientFromRouter<TOriginalClient> = TOriginalClient;

package/trpc/src/index.ts

@@ -1,44 +0,0 @@
-// Re-export server utilities
-export {
-  createTRPCServerRouter,
-  createTRPCContext,
-  router,
-  mergeRouters,
-  type TRPCRouterFromClient
-} from './server';
-
-// Re-export client utilities
-export {
-  createTRPCClient,
-  createTRPCClientWithSessionProvider,
-  type TRPCClientOptions,
-  type SessionProvider,
-  type TRPCClientFromRouter
-} from './client';
-
-// Re-export type utilities
-export {
-  type ClientMethodMap,
-  type MethodInfo,
-  type TRPCMethodInput,
-  type TransparentClient,
-  introspectClient,
-  isQueryMethod,
-  isMutationMethod
-} from './types';
-
-// Legacy exports for backward compatibility
-import { initTRPC } from '@trpc/server';
-import type { Client, RequestContext} from '@reactionary/core';
-import { Session } from '@reactionary/core';
-import { createTRPCTracing } from '@reactionary/otel';
-
-const t = initTRPC.context<{ client: Client; reqCtx: RequestContext }>().create({});
-
-// Always apply tracing middleware - exporters controlled via OTEL env vars
-const basePublicProcedure = t.procedure;
-export const publicProcedure = basePublicProcedure.use(createTRPCTracing());
-
-// Legacy function - deprecated, use createTRPCServerRouter instead
-import { createTRPCServerRouter } from './server';
-export const createTRPCRouter = createTRPCServerRouter;