Middleware Subsystem

import { Apophis } from '@apophis-sdk/core';
import { DefaultCosmosMiddlewares } from '@apophis-sdk/cosmos';
import { DefaultCosmWasmMiddlewares } from '@apophis-sdk/cosmwasm';

Apophis.use(...DefaultCosmosMiddlewares, ...DefaultCosmWasmMiddlewares);

import { type MiddlewareImpl } from '@apophis-sdk/core/middleware.js';

const MyMiddleware1 = {
  addresses: {
    alias(address: string): string {
      return address;
    },
  },
} satisfies MiddlewareImpl;

const MyMiddleware2: MiddlewareImpl = {
  addresses: {
    resolve(address: string): string {
      return address;
    },
  },
  encoding: {
    encode(network: NetworkConfig, encoding: string, value: unknown) {
      if (network.ecosystem !== 'cosmos') return;
      if (encoding !== 'json') return;
      return JSON.stringify(value);
    },
  },
};

const MyMiddleware3 = {} satisfies MiddlewareImpl;

interface MiddlewarePipeline<KP extends string[]> {
  /** Helper to invert the pipeline execution order */
  inv(): MiddlewarePipeline<KP>;

  /** Send a single value through the entire pipeline, transforming it along
   * the way.
   *
   * If a middleware returns `undefined` it is simply skipped and the value
   * remains unchanged in this round.
   */
  transform(arg: TransformType<KP>): TransformType<KP>;

  /** Call every middleware endpoint in order, passing in the given arguments.
   * The first middleware that returns any value other than `undefined` wins
   * and its result returned to the callsite.
   *
   * If no middleware returns a value, throws a MiddlewarePipelineError.
   */
  fifo(...args: FifoArgs<KP>): Defined<FifoResult<KP>>;

  /** Like `fifo` but returns `undefined` rather than throwing an error. */
  fifoMaybe(...args: FifoArgs<KP>): Defined<FifoResult<KP>> | undefined;

  /** Like `fifo` but async. Awaits every middleware in order and can thus be slow. */
  fifoAsync(...args: FifoArgs<KP>): Promise<Awaited<Defined<FifoResult<KP>>>>;

  /** Like `fifoAsync` but returns `undefined` rather than throwing an error. */
  fifoAsyncMaybe(...args: FifoArgs<KP>): Promise<Awaited<Defined<FifoResult<KP>>> | undefined>;

  /** A way for callsites to notify middlewares of some occurrence.
   * The notification handlers may be async. All errors and rejections will
   * be caught and logged with `console.error`.
   */
  notify(...args: NotifyArgs<KP>): Promise<void>;

  /** Like `notify` but the handlers cannot be async. */
  notifySync(...args: NotifyArgs<KP>): void;

  /** A reducer to iterate over and invoke all middlewares in order,
   * aggregating their result by some arbitrary logic.
   *
   * Admittedly, typing this reducer is tough and needs more work.
   */
  reduce(args: any[], reducer: (result: any, response: any) => any, initial: any): any;
}

import { mw } from '@apophis-sdk/core';

const addr = mw('addresses', 'compute').inv().fifo(network, pubkey);

import { mw } from '@apophis-sdk/core/middleware.js';
import { MemoryAddressBook } from '@apophis-sdk/core/address.js';

// Insert a middleware before `MemoryAddressBook` or append to the end if not found
let idx = mw.stack.findIndex(m => m instanceof MemoryAddressBook);
if (idx !== -1) {
  mw.stack.splice(idx, 0, MyMiddleware);
} else {
  mw.stack.push(MyMiddleware);
}