@reactionary/source 0.0.31 → 0.0.32

package/core/package.json

@@ -4,6 +4,6 @@
   "dependencies": {
     "zod": "4.0.0-beta.20250430T185432",
     "@upstash/redis": "^1.34.9",
-    "@reactionary/otel": "0.0.1"
+    "reflect-metadata": "0.2.2"
   }
 }

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

@@ -0,0 +1,63 @@
+import { Cache } from "../cache/cache.interface";
+import { NoOpCache } from "../cache/noop-cache";
+import { Client } from "./client";
+import { AnalyticsProvider } from "../providers/analytics.provider";
+
+type CapabilityFactory<T> = (cache: Cache) => T;
+
+type MergeCapabilities<Acc, New> = Omit<Acc, keyof New> & New;
+
+export class ClientBuilder<TClient = object> {
+    private factories: Array<CapabilityFactory<Partial<Client>>> = [];
+    private cache: Cache | undefined;
+
+    withCapability<TNew extends Partial<Client>>(
+        factory: CapabilityFactory<TNew>
+    ): ClientBuilder<MergeCapabilities<TClient, TNew>> {
+        const newBuilder = new ClientBuilder<MergeCapabilities<TClient, TNew>>();
+        newBuilder.factories = [...this.factories, factory];
+        newBuilder.cache = this.cache;
+        return newBuilder;
+    }
+
+    withCache(cache: Cache): ClientBuilder<TClient> {
+        const newBuilder = new ClientBuilder<TClient>();
+        newBuilder.factories = [...this.factories];
+        newBuilder.cache = cache;
+        return newBuilder;
+    }
+
+    build(): TClient & { cache: Cache } {
+        let client = {} as TClient;
+        
+        // Use provided cache or default to NoOpCache
+        const sharedCache = this.cache || new NoOpCache();
+        
+        const mergedAnalytics: AnalyticsProvider[] = [];
+        
+        for (const factory of this.factories) {
+            const provider = factory(sharedCache);
+            client = {
+                ...client,
+                ...provider
+            };
+            
+            if (provider.analytics) {
+                mergedAnalytics.push(...provider.analytics);
+            }
+        }
+        
+        // Add merged analytics if any were collected
+        if (mergedAnalytics.length > 0) {
+            (client as Record<string, unknown>)['analytics'] = mergedAnalytics;
+        }
+        
+        // Add cache to complete the client
+        const completeClient = {
+            ...client,
+            cache: sharedCache
+        } as TClient & { cache: Cache };
+        
+        return completeClient;
+    }
+}

package/core/src/decorators/trpc.decorators.ts

@@ -0,0 +1,144 @@
+import 'reflect-metadata';
+
+/**
+ * Metadata keys for TRPC method decorators
+ */
+export const TRPC_QUERY_METADATA_KEY = Symbol('trpc:query');
+export const TRPC_MUTATION_METADATA_KEY = Symbol('trpc:mutation');
+
+
+
+/**
+ * Options for TRPC method decorators
+ */
+export interface TRPCMethodOptions {
+  /** Custom name for the TRPC procedure (defaults to method name) */
+  name?: string;
+  /** Description for documentation purposes */
+  description?: string;
+}
+
+/**
+ * Decorator to mark a provider method as a TRPC query procedure
+ * Query procedures are read-only operations (GET-like)
+ * 
+ * @example
+ * ```typescript
+ * class ProductProvider extends BaseProvider {
+ *   @trpcQuery()
+ *   async getById(payload: ProductQueryById, session: Session): Promise<Product> {
+ *     // implementation
+ *   }
+ * 
+ *   @trpcQuery({ name: 'findBySlug', description: 'Find product by URL slug' })
+ *   async getBySlug(payload: ProductQueryBySlug, session: Session): Promise<Product> {
+ *     // implementation
+ *   }
+ * }
+ * ```
+ */
+export function trpcQuery(options: TRPCMethodOptions = {}): MethodDecorator {
+  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
+    // Store metadata about this method being a TRPC query
+    const metadata = {
+      methodName: String(propertyKey),
+      isQuery: true,
+      isMutation: false,
+      options
+    };
+
+    // Store on the prototype so it's inherited
+    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, metadata, target, propertyKey);
+    
+    // Also store a list of all TRPC methods on the class
+    const existingMethods = Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target.constructor) || [];
+    existingMethods.push({ propertyKey, metadata });
+    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, existingMethods, target.constructor);
+  };
+}
+
+/**
+ * Decorator to mark a provider method as a TRPC mutation procedure
+ * Mutation procedures are write operations that modify state (POST/PUT/DELETE-like)
+ * 
+ * @example
+ * ```typescript
+ * class CartProvider extends BaseProvider {
+ *   @trpcMutation()
+ *   async add(payload: CartAddMutation, session: Session): Promise<Cart> {
+ *     // implementation
+ *   }
+ * 
+ *   @trpcMutation({ name: 'removeItem' })
+ *   async remove(payload: CartRemoveMutation, session: Session): Promise<Cart> {
+ *     // implementation  
+ *   }
+ * }
+ * ```
+ */
+export function trpcMutation(options: TRPCMethodOptions = {}): MethodDecorator {
+  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
+    // Store metadata about this method being a TRPC mutation
+    const metadata = {
+      methodName: String(propertyKey),
+      isQuery: false,
+      isMutation: true,
+      options
+    };
+
+    // Store on the prototype so it's inherited
+    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, metadata, target, propertyKey);
+    
+    // Also store a list of all TRPC methods on the class
+    const existingMethods = Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target.constructor) || [];
+    existingMethods.push({ propertyKey, metadata });
+    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, existingMethods, target.constructor);
+  };
+}
+
+/**
+ * Get all TRPC query methods from a class or instance
+ */
+export function getTRPCQueryMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
+  const constructor = typeof target === 'function' ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, constructor) || [];
+}
+
+/**
+ * Get all TRPC mutation methods from a class or instance
+ */
+export function getTRPCMutationMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
+  const constructor = typeof target === 'function' ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, constructor) || [];
+}
+
+/**
+ * Get all TRPC methods (both queries and mutations) from a class or instance
+ */
+export function getAllTRPCMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
+  return [
+    ...getTRPCQueryMethods(target),
+    ...getTRPCMutationMethods(target)
+  ];
+}
+
+/**
+ * Check if a method is marked as a TRPC query
+ */
+export function isTRPCQuery(target: any, methodName: string | symbol): boolean {
+  return !!Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target, methodName);
+}
+
+/**
+ * Check if a method is marked as a TRPC mutation
+ */
+export function isTRPCMutation(target: any, methodName: string | symbol): boolean {
+  return !!Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target, methodName);
+}
+
+/**
+ * Check if a method is marked for TRPC exposure (query or mutation)
+ */
+export function isTRPCMethod(target: any, methodName: string | symbol): boolean {
+  return isTRPCQuery(target, methodName) || isTRPCMutation(target, methodName);
+}

package/core/src/index.ts

@@ -4,6 +4,9 @@ export * from './cache/redis-cache';
 export * from './cache/noop-cache';
 
 export * from './client/client';
+export * from './client/client-builder';
+
+export * from './decorators/trpc.decorators';
 
 export * from './providers/analytics.provider';
 export * from './providers/base.provider';

package/core/src/providers/analytics.provider.ts

@@ -1,33 +1,7 @@
 import { AnalyticsEvent } from '../schemas/models/analytics.model';
-import { AnalyticsMutation } from '../schemas/mutations/analytics.mutation';
-import { AnalyticsQuery } from '../schemas/queries/analytics.query';
 import { BaseProvider } from './base.provider';
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
-import { Session } from '../schemas/session.schema';
-import * as crypto from 'crypto';
 
 export abstract class AnalyticsProvider<
-  T extends AnalyticsEvent = AnalyticsEvent,
-  Q extends AnalyticsQuery = AnalyticsQuery,
-  M extends AnalyticsMutation = AnalyticsMutation
-> extends BaseProvider<T, Q, M> {
-  
-  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
-    const providerName = this.constructor.name.toLowerCase();
-    
-    // Hash analytics query parameters
-    const relevantFields = {
-      type: typeof query === 'object' && query !== null && 'type' in query ? (query as any).type : undefined,
-      dateRange: typeof query === 'object' && query !== null && 'dateRange' in query ? (query as any).dateRange : undefined,
-      filters: typeof query === 'object' && query !== null && 'filters' in query ? (query as any).filters : undefined
-    };
-    const analyticsHash = crypto.createHash('md5').update(JSON.stringify(relevantFields)).digest('hex').substring(0, 12);
-    const key = `${providerName}:analytics:${analyticsHash}`;
-    
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
+  T extends AnalyticsEvent = AnalyticsEvent
+> extends BaseProvider<T> {
 }

package/core/src/providers/base.provider.ts

@@ -1,32 +1,20 @@
 import { z } from 'zod';
-import { Session } from '../schemas/session.schema';
-import { BaseQuery } from '../schemas/queries/base.query';
-import { BaseMutation } from '../schemas/mutations/base.mutation';
 import { BaseModel } from '../schemas/models/base.model';
-import { createProviderInstrumentation } from '@reactionary/otel';
 import { Cache } from '../cache/cache.interface';
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
-import * as crypto from 'crypto';
 
 /**
  * Base capability provider, responsible for mutations (changes) and queries (fetches)
  * for a given business object domain.
  */
 export abstract class BaseProvider<
-  T extends BaseModel = BaseModel,
-  Q extends BaseQuery = BaseQuery,
-  M extends BaseMutation = BaseMutation
+  T extends BaseModel = BaseModel
 > {
-  protected instrumentation: ReturnType<typeof createProviderInstrumentation>;
   protected cache: Cache;
   
   constructor(
-    public readonly schema: z.ZodType<T>, 
-    public readonly querySchema: z.ZodType<Q, Q>, 
-    public readonly mutationSchema: z.ZodType<M, M>,
+    public readonly schema: z.ZodType<T>,
     cache: Cache
   ) {
-    this.instrumentation = createProviderInstrumentation(this.constructor.name);
     this.cache = cache;
   }
 
@@ -46,128 +34,12 @@ export abstract class BaseProvider<
   }
 
   /**
-   * Retrieves a set of entities matching the list of queries. The size of
-   * the resulting list WILL always match the size of the query list. The
-   * result list will never contain nulls or undefined. The order
-   * of the results will match the order of the queries.
+   * Handler for parsing a response from a remote provider and converting it
+   * into the typed domain model.
    */
-  public async query(queries: Q[], session: Session): Promise<T[]> {
-    return this.instrumentation.traceQuery(
-      'query',
-      async (span) => {
-        span.setAttribute('provider.query.count', queries.length);
-        
-        let cacheHits = 0;
-        let cacheMisses = 0;
-        const results: T[] = [];
+  protected parseSingle(_body: unknown): T {
+    const model = this.newModel();
 
-        // Process each query individually for cache efficiency
-        for (const query of queries) {
-          let result: T | null = null;
-          
-          // Get cache evaluation from provider
-          const cacheInfo = this.getCacheEvaluation(query, session);
-          
-          // Try cache first if caching is enabled
-          if (cacheInfo.canCache && cacheInfo.key) {
-            try {
-              result = await this.cache.get(cacheInfo.key, this.schema);
-              if (result) {
-                cacheHits++;
-                span.setAttribute('provider.cache.hit', true);
-              }
-            } catch (error) {
-              // Cache error shouldn't break the query - log and continue
-              console.warn(`Cache get error for ${this.constructor.name}:`, error);
-            }
-          }
-          
-          // If not in cache, fetch from source
-          if (!result) {
-            const singleResult = await this.fetch([query], session);
-            result = singleResult[0];
-            cacheMisses++;
-            
-            // Store in cache if caching is enabled
-            if (result && cacheInfo.canCache && cacheInfo.key) {
-              try {
-                await this.cache.put(cacheInfo.key, result, cacheInfo.cacheDurationInSeconds);
-              } catch (error) {
-                // Cache put error shouldn't break the query - log and continue
-                console.warn(`Cache put error for ${this.constructor.name}:`, error);
-              }
-            }
-          }
-          
-          if (result) {
-            this.assert(result);
-            results.push(result);
-          }
-        }
-
-        span.setAttribute('provider.result.count', results.length);
-        span.setAttribute('provider.cache.hits', cacheHits);
-        span.setAttribute('provider.cache.misses', cacheMisses);
-        span.setAttribute('provider.cache.hit_ratio', cacheHits / (cacheHits + cacheMisses));
-        
-        return results;
-      },
-      { queryCount: queries.length }
-    );
-  }
-
-  /**
-   * Executes the listed mutations in order and returns the final state
-   * resulting from that set of operations.
-   */
-  public async mutate(mutations: M[], session: Session): Promise<T> {
-    return this.instrumentation.traceMutation(
-      'mutate',
-      async (span) => {
-        span.setAttribute('provider.mutation.count', mutations.length);
-        
-        // Perform the mutation
-        const result = await this.process(mutations, session);
-        this.assert(result);
-
-        return result;
-      },
-      { mutationCount: mutations.length }
-    );
-  }
-
-  /**
-   * The internal extension point for providers implementating query
-   * capabilities.
-   */
-  protected abstract fetch(queries: Q[], session: Session): Promise<T[]>;
-
-  /**
-   * The internal extension point for providers implementing mutation
-   * capabilities.
-   */
-  protected abstract process(
-    mutations: M[],
-    session: Session
-  ): Promise<T>;
-
-  /**
-   * Provider-specific cache evaluation logic.
-   * Returns information about how this query should be cached.
-   * Override this method to enable caching with custom keys and TTL.
-   * Default implementation returns no caching.
-   */
-  protected getCacheEvaluation(query: Q, session: Session): CacheEvaluation {
-    // Default implementation: generate a cache key but don't cache
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id || 'anonymous';
-    const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
-    const key = `${providerName}:${userId}:${queryHash}`;
-    
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
+    return this.assert(model);
   }
 }

package/core/src/providers/cart.provider.ts

@@ -1,27 +1,14 @@
-import { CartQuery } from "../schemas/queries/cart.query";
-import { CartMutation } from "../schemas/mutations/cart.mutation";
 import { BaseProvider } from "./base.provider";
 import { Cart } from "../schemas/models/cart.model";
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
-import { Session } from '../schemas/session.schema';
-import * as crypto from 'crypto';
+import { CartQueryById } from "../schemas/queries/cart.query";
+import { Session } from "../schemas/session.schema";
+import { CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove } from "../schemas/mutations/cart.mutation";
 
 export abstract class CartProvider<
-  T extends Cart = Cart,
-  Q extends CartQuery = CartQuery,
-  M extends CartMutation = CartMutation
-> extends BaseProvider<T, Q, M> {
-  
-  protected override getCacheEvaluation(query: Q, session: Session): CacheEvaluation {
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id || 'anonymous';
-    const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
-    const key = `${providerName}:cart:${userId}:${queryHash}`;
-    
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
+  T extends Cart = Cart
+> extends BaseProvider<T> {
+  public abstract getById(payload: CartQueryById, session: Session): Promise<T>;
+  public abstract add(payload: CartMutationItemAdd, session: Session): Promise<T>;
+  public abstract remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
+  public abstract changeQuantity(payload: CartMutationItemQuantityChange, session: Session): Promise<T>;
 }

package/core/src/providers/identity.provider.ts

@@ -1,27 +1,13 @@
 import { Identity } from "../schemas/models/identity.model";
-import { IdentityQuery } from "../schemas/queries/identity.query";
-import { IdentityMutation } from "../schemas/mutations/identity.mutation";
+import { IdentityMutationLogin, IdentityMutationLogout } from "../schemas/mutations/identity.mutation";
+import { IdentityQuerySelf } from "../schemas/queries/identity.query";
+import { Session } from "../schemas/session.schema";
 import { BaseProvider } from "./base.provider";
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
-import { Session } from '../schemas/session.schema';
 
 export abstract class IdentityProvider<
   T extends Identity = Identity,
-  Q extends IdentityQuery = IdentityQuery,
-  M extends IdentityMutation = IdentityMutation
-> extends BaseProvider<T, Q, M> {
-  
-  protected override getCacheEvaluation(_query: Q, session: Session): CacheEvaluation {
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id;
-    const key = userId 
-      ? `${providerName}:identity:${userId}`
-      : `${providerName}:identity:anonymous`;
-    
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
+> extends BaseProvider<T> {
+  public abstract getSelf(payload: IdentityQuerySelf, session: Session): Promise<T>;
+  public abstract login(payload: IdentityMutationLogin, session: Session): Promise<T>;
+  public abstract logout(payload: IdentityMutationLogout, session: Session): Promise<T>;
 }

package/core/src/providers/inventory.provider.ts

@@ -1,24 +1,10 @@
 import { Inventory } from '../schemas/models/inventory.model';
 import { InventoryQuery } from '../schemas/queries/inventory.query';
-import { InventoryMutation } from '../schemas/mutations/inventory.mutation';
-import { BaseProvider } from './base.provider';
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
 import { Session } from '../schemas/session.schema';
+import { BaseProvider } from './base.provider';
 
 export abstract class InventoryProvider<
-  T extends Inventory = Inventory,
-  Q extends InventoryQuery = InventoryQuery,
-  M extends InventoryMutation = InventoryMutation
-> extends BaseProvider<T, Q, M> {
-  
-  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
-    const providerName = this.constructor.name.toLowerCase();
-    const key = `${providerName}:inventory:${query.sku}`;
-    
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
+  T extends Inventory = Inventory
+> extends BaseProvider<T> {
+  public abstract getBySKU(payload: InventoryQuery, session: Session): Promise<T>;
 }

package/core/src/providers/price.provider.ts

@@ -1,27 +1,10 @@
 import { Price } from '../schemas/models/price.model';
-import { PriceMutation } from '../schemas/mutations/price.mutation';
-import { PriceQuery } from '../schemas/queries/price.query';
-import { BaseProvider } from './base.provider';
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { PriceQueryBySku } from '../schemas/queries/price.query';
 import { Session } from '../schemas/session.schema';
-import * as crypto from 'crypto';
+import { BaseProvider } from './base.provider';
 
 export abstract class PriceProvider<
-  T extends Price = Price,
-  Q extends PriceQuery = PriceQuery,
-  M extends PriceMutation = PriceMutation
-> extends BaseProvider<T, Q, M> {
-  
-  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
-    const providerName = this.constructor.name.toLowerCase();
-    // Hash complex SKU objects (price queries with currency, customer group, etc.)
-    const skuHash = crypto.createHash('md5').update(JSON.stringify(query.sku)).digest('hex').substring(0, 12);
-    const key = `${providerName}:price:${skuHash}`;
-    
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
+  T extends Price = Price
+> extends BaseProvider<T> {
+  public abstract getBySKU(payload: PriceQueryBySku, session: Session): Promise<T>;
 }

package/core/src/providers/product.provider.ts

@@ -1,34 +1,11 @@
 import { Product } from '../schemas/models/product.model';
-import { ProductMutation } from '../schemas/mutations/product.mutation';
-import { ProductQuery, ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
 import { BaseProvider } from './base.provider';
 import { Session } from '../schemas/session.schema';
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
-import * as crypto from 'crypto';
+import { ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
 
 export abstract class ProductProvider<
-  T extends Product = Product,
-  Q extends ProductQuery = ProductQuery,
-  M extends ProductMutation = ProductMutation
-> extends BaseProvider<T, Q, M> {
-  
-  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
-    const providerName = this.constructor.name.toLowerCase();
-    
-    let key: string;
-    if (query.query === 'slug') {
-      key = `${providerName}:product:slug:${(query as ProductQueryBySlug).slug}`;
-    } else if (query.query === 'id') {
-      key = `${providerName}:product:id:${(query as ProductQueryById).id}`;
-    } else {
-      const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
-      key = `${providerName}:product:${queryHash}`;
-    }
-    
-    return {
-      key,
-      cacheDurationInSeconds: 300, // Products are moderately stable - 5 minutes
-      canCache: true
-    };
-  }
+  T extends Product = Product
+> extends BaseProvider<T> {
+  public abstract getById(payload: ProductQueryById, session: Session): Promise<T>;
+  public abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T>;
 }

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

@@ -1,29 +1,12 @@
 import { SearchResult } from '../schemas/models/search.model';
-import { SearchQuery } from '../schemas/queries/search.query';
-import { SearchMutation } from '../schemas/mutations/search.mutation';
-import { BaseProvider } from './base.provider';
-import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { SearchQueryByTerm } from '../schemas/queries/search.query';
 import { Session } from '../schemas/session.schema';
-import * as crypto from 'crypto';
+import { BaseProvider } from './base.provider';
 
 export abstract class SearchProvider<
-  T extends SearchResult = SearchResult,
-  Q extends SearchQuery = SearchQuery,
-  M extends SearchMutation = SearchMutation
-> extends BaseProvider<T, Q, M> {
-  
-  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
-    const providerName = this.constructor.name.toLowerCase();
-    // Hash search parameters (term, filters, pagination, etc.)
-    const searchHash = crypto.createHash('md5').update(JSON.stringify(query.search)).digest('hex').substring(0, 12);
-    const key = `${providerName}:search:${searchHash}`;
-    
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
+  T extends SearchResult = SearchResult
+> extends BaseProvider<T> {
+  public abstract queryByTerm(payload: SearchQueryByTerm, session: Session): Promise<SearchResult>;
 }
 
 

package/core/src/schemas/mutations/base.mutation.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 
 export const BaseMutationSchema = z.looseInterface({
-    mutation: z.ZodLiteral
 });
 
 export type BaseMutation = z.infer<typeof BaseMutationSchema>;