@pallad/graphql-command-bus/compiled/Mapper.d.ts

import { Validation } from "monet";
import { ObjectTypeComposer, ResolverResolveParams } from "graphql-compose";
import { DataLoaderManager } from '@pallad/dataloader-manager';
import { EntityHelper } from './EntityHelper';
import { Command, CommandRunner } from 'alpha-command-bus-core';
export declare class Mapper<TContextOptions = any, TDataLoaderContext = any, TGQLContext extends Mapper.BasicGQLContext<TDataLoaderContext> = any> {
    private commandBusHandler;
    private dataLoaderManager;
    constructor(commandBusHandler: CommandRunner<any, Mapper.ExecutionContext<TContextOptions, TGQLContext | TDataLoaderContext>>, dataLoaderManager: DataLoaderManager);
    handleCommand<TExecutionContext extends Mapper.ExecutionContext<any, any>>(command: Command, executionContext: TExecutionContext, resultHandler?: Mapper.ResultHandler<TExecutionContext>): Promise<any>;
    createResolver<TArgs = any, TSource = any>(options: Mapper.CreateResolverOptions<TContextOptions, TGQLContext, TArgs, TSource>): Mapper.Resolver<TArgs, TSource, TGQLContext>;
    createDataLoaderResolver(dataLoaderName: string, argKeyName?: string): (rp: ResolverResolveParams<any, TGQLContext>) => Promise<unknown> | undefined;
    createEntityHelper<TEntity = any>(entityType: ObjectTypeComposer<TEntity, TGQLContext>): EntityHelper<TEntity, TContextOptions, TDataLoaderContext>;
}
export declare namespace Mapper {
    interface ExecutionContext<TContextOptions, TGQLContext> {
        contextOptions: TContextOptions;
        gqlContext: TGQLContext;
    }
    type ResolverFunc<TArgs, TSource, TGQLContext> = (source: TSource, args: TArgs, context: TGQLContext) => Promise<any>;
    interface Resolver<TArgs, TSource, TGQLContext> extends ResolverFunc<TArgs, TSource, TGQLContext> {
        rp: (rp: ResolverResolveParams<TSource, TGQLContext, TArgs>) => Promise<any>;
    }
    interface BasicGQLContext<TDataLoaderContext = any> {
        dataLoaders: DataLoaderManager.Scope<TDataLoaderContext>;
    }
    type ResultHandler<TExecutionContext> = (result: Validation<any, any>, executionContext: TExecutionContext) => Validation<any, any> | Promise<Validation<any, any>>;
    type CreateResolverOptions<TContextOptions, TGQLContext, TArgs extends Record<string, any>, TSource = any> = {
        commandFactory: (data: {
            args: TArgs;
            source: TSource;
            context: TGQLContext;
        }) => Promise<Command> | Command;
        resultHandler?: ResultHandler<ExecutionContext<TContextOptions, TGQLContext>>;
    } & (TContextOptions extends undefined ? {
        context?: NonNullable<TContextOptions>;
    } : {
        context: TContextOptions;
    });
}