api-internal.ts

// deno-lint-ignore-file ban-types no-explicit-any
import { createContext } from "./context.ts";
import { useScope } from "./scope.ts";
import type {
  Api,
  Around,
  Context,
  Middleware,
  Operation,
  Scope,
} from "./types.ts";
import type { ScopeInternal } from "./scope-internal.ts";

export interface ApiInternal<A> extends Api<A> {
  context: Context<{
    max: Partial<Around<A>>[];
    min: Partial<Around<A>>[];
  }>;
  core: A;
}

export function createApiInternal<A extends {}>(
  name: string,
  core: A,
): ApiInternal<A> {
  let fields = Object.keys(core) as (keyof A)[];

  let context = createContext(`api::${name}`) as ApiInternal<A>["context"];

  let api: ApiInternal<A> = {
    core,
    context,
    invoke: (scope, key, args) => {
      let handle = createHandle(api, scope);
      let member = handle[key];
      if (typeof member === "function") {
        return member(...args);
      } else {
        return member;
      }
    },
    around: (decorator, options = { at: "max" }) => ({
      *[Symbol.iterator]() {
        let scope = yield* useScope();
        scope.around(api, decorator, options);
      },
    }),
    operations: fields.reduce((sum, field) => {
      if (typeof core[field] === "function") {
        return Object.assign(sum, {
          [field]: (...args: any) => ({
            *[Symbol.iterator]() {
              let scope = yield* useScope();
              let target = api.invoke(scope, field, args);

              return isOperation(target) ? yield* target : target;
            },
          }),
        });
      } else {
        return Object.assign(sum, {
          [field]: {
            *[Symbol.iterator]() {
              let scope = yield* useScope();
              let target = api.invoke(scope, field, [] as any);
              return isOperation(target) ? yield* target : target;
            },
          },
        });
      }
    }, {} as Api<A>["operations"]),
  };
  return api;
}

function createHandle<A extends {}>(api: ApiInternal<A>, scope: Scope): A {
  let handle = Object.create(api.core);
  let $scope = scope as ScopeInternal;
  for (let key of Object.keys(api.core) as Array<keyof A>) {
    let dispatch = (args: unknown[], next: (...args: unknown[]) => unknown) => {
      let { min, max } = $scope.reduce(api.context, (sum, current) => {
        let min = current.min.flatMap((around) =>
          around[key] ? [around[key]] : []
        );
        let max = current.max.flatMap((around) =>
          around[key] ? [around[key]] : []
        );

        sum.min.push(...min);
        sum.max.unshift(...max);

        return sum;
      }, {
        min: [] as Around<A>[typeof key][],
        max: [] as Around<A>[typeof key][],
      });

      let stack = combine(
        max.concat(min) as Middleware<unknown[], unknown>[],
      );
      return stack(args, next);
    };

    if (typeof api.core[key] === "function") {
      handle[key] = (...args: unknown[]) =>
        dispatch(args, api.core[key] as (...args: unknown[]) => unknown);
    } else {
      Object.defineProperty(handle, key, {
        enumerable: true,
        get() {
          return dispatch([], () => api.core[key]);
        },
      });
    }
  }
  return handle;
}

function isOperation<T>(
  target: Operation<T> | T,
): target is Operation<T> {
  return target && !isNativeIterable(target) &&
    typeof (target as Operation<T>)[Symbol.iterator] === "function";
}

function isNativeIterable(target: unknown): boolean {
  return (
    typeof target === "string" || Array.isArray(target) ||
    target instanceof Map || target instanceof Set
  );
}

function combine<TArgs extends unknown[], TReturn>(
  middlewares: Middleware<TArgs, TReturn>[],
): Middleware<TArgs, TReturn> {
  if (middlewares.length === 0) {
    return (args, next) => next(...args);
  }
  return middlewares.reduceRight((sum, middleware) => (args, next) =>
    middleware(args, (...args) => sum(args, next))
  );
}