export type PessimisticUpdateConfig<Data, Response> = {
  mode: 'pessimistic',
  query: Query<any, Data, any>,
  mutation: Mutation<any, Response, any>
} & (Response extends Data ? {
  mapResponse?: (response: Response) => Data
} : {
  mapResponse: (response: Response) => Data
});

export function update<Data, Response>(config: PessimisticUpdateConfig<Data, Response>): void {/*...*/}

export type GeneralUpdateConfig<Data, EventPayload> = {
  mode: 'general',
  query: Query<any, Data, any>,
  fn: (payload: EventPayload) => Data
};

export function update<Data, EventPayload>(config: GeneralUpdateConfig<Data, EventPayload>): Event<EventPayload> {/*...*/}

import {
  Mutation,
  Query,
  TwoArgsDynamicallySourcedField,
  ThreeArgsDynamicallySourcedField
} from '@farfetched/core';

type ExcludeVoid<T> = Pick<
  T,
  {
    [K in keyof T]: T[K] extends void ? never : K;
  }[keyof T]
>;

type MapperBaseArgs<Data, MutationParams> = {
  queryData: Data;
  mutationParams: MutationParams;
};

type Extends<Specific, Wide> = Specific extends Wide ? true : false;

type Conditional<Condition, T> = Condition extends true
  ? Partial<T>
  : Required<T>;

type BasicUpdateConfig<Data, QueryParams, MutationParams, Response, Error> = {
  query: Query<QueryParams, Data, any>;
  mutation: Mutation<MutationParams, Response, Error>;
  fromError?: (
    args: ExcludeVoid<
      MapperBaseArgs<Data, MutationParams> & {
        error: Error;
        pristineData?: Data;
      }
    >
  ) => Data;
};

export type PessimisticUpdateConfig<
  Data,
  QueryParams,
  MutationParams,
  Response,
  Source,
  Error
> = BasicUpdateConfig<Data, QueryParams, MutationParams, Response, Error> &
  Conditional<
    Extends<Response, Data>,
    {
      map: ThreeArgsDynamicallySourcedField<
        Data,
        { queryParams: QueryParams; mutationParams: MutationParams },
        Response,
        Data,
        Source
      >;
    }
  >;

export type OptimisticUpdateConfig<
  Data,
  QueryParams,
  MutationParams,
  Response,
  Source,
  RefetchSource,
  Error
> = (BasicUpdateConfig<Data, QueryParams, MutationParams, Response, Error> & {
  refetch?: ThreeArgsDynamicallySourcedField<
    Data,
    { queryParams: QueryParams; mutationParams: MutationParams },
    Error,
    { params: QueryParams },
    RefetchSource
  >;
}) &
  Conditional<
    Extends<MutationParams, Data>,
    {
      map: TwoArgsDynamicallySourcedField<Data, MutationParams, Data, Source>;
    }
  >;

export function pessimisticUpdate<
  Data,
  QueryParams,
  MutationParams,
  Response,
  Source,
  Error
>(
  config: PessimisticUpdateConfig<
    Data,
    QueryParams,
    MutationParams,
    Response,
    Source,
    Error
  >
): void {}

export function optimisticUpdate<
  Data,
  QueryParams,
  MutationParams,
  Response,
  Source,
  RefetchSource,
  Error
>(
  config: OptimisticUpdateConfig<
    Data,
    QueryParams,
    MutationParams,
    Response,
    Source,
    RefetchSource,
    Error
  >
): void {}

const query = createQuery({
  handler: async (x: number) => ({
    id: x,
    name: '',
  }),
});

const mutation = createMutation({
  effect: createEffect(async (_: { id: string; name: number }) => ({
    id: 2,
  })),
});

pessimisticUpdate({
  query,
  mutation,
  map: {
    source: createStore('literal' as const),
    fn(queryData, params, response, source) {
      return {
        id: ++response.id,
        name: source,
      };
    },
  },
  fromError({error, pristineData}) {
    console.warn(`mutation ended with an error: ${error.message}`);
    
    function createExpectedData(): NonNullable<typeof pristineData> {
      /* ... */
    }
    
    const origData = pristineData ?? createExpectedData();

    return origData
  }
});

optimisticUpdate({
  query,
  mutation,
  map(queryData, mutationParams) {
    return {
      id: parseInt(mutationParams.id) + 1,
      name: mutationParams.name.toString(),
    };
  },
  refetch: {
    source: createStore(42 as const),
    fn(queryData, { queryParams, mutationParams }, error, source) {
      return '';
    },
    // ^ Type 'string' is not assignable to type '{ params: number; }'.
  },
});