feat: implement middleware system & basic middlewares

Author: ChibiBlasphem

packages/app-builder/src/core/middleware-config.ts

@@ -0,0 +1,3 @@
+export interface MiddlewareConfig {
+  GlobalMiddlewares: readonly [];
+}

packages/app-builder/src/core/middleware-types.ts

@@ -0,0 +1,85 @@
+export type Expand<T> = T extends object
+  ? T extends infer O
+    ? O extends Function
+      ? O
+      : {
+          [K in keyof O]: O[K];
+        }
+    : never
+  : T;
+
+export type DataReturnType<Data, TContext> = {
+  data: Data;
+  __context: TContext;
+  __headers: HeaderEntry[];
+};
+
+export type HeaderEntry = [string, string];
+
+export type NextFunction = <TOutContext = undefined>(ctx?: {
+  context: TOutContext;
+  headers?: HeaderEntry[];
+}) => Promise<DataReturnType<any, TOutContext>>;
+
+export type DataFunctionArgs<TInContext> = {
+  request: Request;
+  params: Record<string, string>;
+  context: TInContext;
+};
+
+export type MiddlewareFunction<in out TInContext = any, TOutContext = any> = (
+  args: DataFunctionArgs<TInContext>,
+  next: NextFunction,
+) => Promise<DataReturnType<any, TOutContext>>;
+
+export type MiddlewareObject<
+  TDependencies extends readonly MiddlewareObject[] = any,
+  TOutContext = any,
+> = {
+  deps: readonly [...TDependencies];
+  fn: MiddlewareFunction<Expand<MergeMiddlewareContext<TDependencies>>, TOutContext>;
+};
+
+export type MergeMiddlewareContext<T extends readonly MiddlewareObject[]> = T extends readonly [
+  infer M,
+]
+  ? M extends MiddlewareObject<any, infer TOutContext>
+    ? TOutContext
+    : never
+  : T extends readonly [infer M, ...infer R extends readonly MiddlewareObject[]]
+    ? M extends MiddlewareObject<any, infer TOutContext>
+      ? TOutContext & MergeMiddlewareContext<R>
+      : never
+    : {};
+
+export type ExecutionEnvironmentQueueItem = {
+  data: { context: any } | undefined;
+};
+
+export type ExecutionEnvironment = {
+  queue: Map<Function, ExecutionEnvironmentQueueItem>;
+  ctx: {
+    request: Request;
+    params: Record<string, string>;
+    context: Record<string, unknown>;
+  };
+};
+
+export type DataWithOptions<Data> = {
+  __dataObject: true;
+  data: Data;
+  headers?: HeaderEntry[];
+};
+
+export type ServerFunction<TContext, Data> = (
+  args: DataFunctionArgs<TContext>,
+) => Promise<Data | DataWithOptions<Data>>;
+
+export type RemixDataFunctionArgs = {
+  request: Request;
+  params: Record<string, string>;
+};
+
+export type TypedResponse<T = unknown> = T extends Response
+  ? T
+  : Omit<Response, 'json'> & { json(): Promise<T> };

packages/app-builder/src/core/requests.ts

@@ -0,0 +1,169 @@
+export type GlobalMiddlewares =
+  import('@app-builder/core/middleware-config').MiddlewareConfig['GlobalMiddlewares'];
+
+import { TypedResponse } from '@remix-run/server-runtime';
+import type {
+  DataReturnType,
+  DataWithOptions,
+  ExecutionEnvironment,
+  ExecutionEnvironmentQueueItem,
+  Expand,
+  HeaderEntry,
+  MergeMiddlewareContext,
+  MiddlewareFunction,
+  MiddlewareObject,
+  NextFunction,
+  RemixDataFunctionArgs,
+  ServerFunction,
+} from './middleware-types';
+
+let globalMiddlewares: readonly MiddlewareObject[] = [];
+
+const isDataWithOptions = (data: any): data is DataWithOptions<any> => {
+  return data instanceof Object && '__dataObject' in data && data.__dataObject;
+};
+
+function createMiddlewareCallbable(
+  object: MiddlewareObject,
+  env: ExecutionEnvironment,
+  globalEnv: ExecutionEnvironment | undefined,
+  next: NextFunction,
+) {
+  // Create a env specific to middleware queue to not pollute the global request one
+  const middlewareEnv = createExecutionEnvironment(env);
+  middlewareEnv.ctx.context = { ...globalEnv?.ctx.context };
+
+  const finalMiddleware: NextFunction = async (args): Promise<DataReturnType<any, any>> => {
+    middlewareEnv.ctx.context = { ...middlewareEnv.ctx.context, ...args?.context };
+    return object.fn(middlewareEnv.ctx, next);
+  };
+
+  return createMiddlewareChain(object.deps, middlewareEnv, globalEnv, finalMiddleware);
+}
+
+function createServerFunctionCallable(
+  middlewares: readonly MiddlewareObject[],
+  env: ExecutionEnvironment,
+  fn: ServerFunction<any, any>,
+) {
+  const final: NextFunction = async (args): Promise<DataReturnType<any, any>> => {
+    env.ctx.context = { ...globalEnv.ctx.context, ...env.ctx.context, ...args?.context };
+    const res = await fn(env.ctx);
+    const isResDataObject = isDataWithOptions(res);
+    const data = isResDataObject ? res.data : res;
+    const resHeaders = isResDataObject ? res.headers : [];
+
+    return {
+      data,
+      __context: env.ctx.context,
+      __headers: [...(args?.headers ?? []), ...(resHeaders ?? [])],
+    };
+  };
+
+  const globalEnv = createExecutionEnvironment(env);
+
+  const routeMiddlewareChain = createMiddlewareChain(middlewares, env, globalEnv, final);
+  const globalMiddlewareChain = createMiddlewareChain(
+    globalMiddlewares,
+    globalEnv,
+    undefined,
+    (nextArgs) => {
+      globalEnv.ctx.context = { ...globalEnv.ctx.context, ...nextArgs?.context };
+      return routeMiddlewareChain();
+    },
+  );
+
+  return globalMiddlewareChain;
+}
+
+function createMiddlewareChain(
+  middlewares: readonly MiddlewareObject[],
+  env: ExecutionEnvironment,
+  globalEnv: ExecutionEnvironment | undefined,
+  final: NextFunction,
+): NextFunction {
+  return middlewares.reduceRight<NextFunction>((nextFn, middleware) => {
+    return async (args) => {
+      env.ctx.context = { ...env.ctx.context, ...args?.context };
+
+      const queueItem = env.queue.get(middleware.fn);
+      if (queueItem) {
+        return nextFn(queueItem.data);
+      }
+
+      const callable = createMiddlewareCallbable(middleware, env, globalEnv, (nextArgs) => {
+        env.queue.set(middleware.fn, { data: nextArgs });
+        return nextFn(nextArgs);
+      });
+
+      return callable();
+    };
+  }, final);
+}
+
+function createExecutionEnvironment(
+  ...args: [ExecutionEnvironment] | [Request, Record<string, string>]
+): ExecutionEnvironment {
+  if (args[0] instanceof Request) {
+    return {
+      queue: new Map<Function, ExecutionEnvironmentQueueItem>(),
+      ctx: { context: {}, request: args[0], params: args[1] ?? {} },
+    };
+  }
+
+  return {
+    queue: args[0].queue,
+    ctx: { ...args[0].ctx, context: {} },
+  };
+}
+
+function appendToHeaders(headers: Headers, entries: HeaderEntry[]): Headers {
+  for (const [key, value] of entries) {
+    headers.append(key, value);
+  }
+  return headers;
+}
+
+function buildResponse(ret: DataReturnType<any, any>) {
+  if (ret.data instanceof Response) {
+    return ret.data;
+  }
+
+  const headers = appendToHeaders(new Headers(), ret.__headers);
+  return Response.json(ret.data, { headers });
+}
+
+export function createServerFn<T extends readonly MiddlewareObject[], Ret>(
+  middlewares: readonly [...T],
+  fn: ServerFunction<Expand<MergeMiddlewareContext<[...GlobalMiddlewares, ...T]>>, Ret>,
+) {
+  return async (args: RemixDataFunctionArgs): Promise<TypedResponse<Ret>> => {
+    const env = createExecutionEnvironment(args.request, args.params);
+    const middlewareChain = createServerFunctionCallable(middlewares, env, fn);
+
+    const ret = await middlewareChain();
+    return buildResponse(ret);
+  };
+}
+
+export function createMiddleware<T extends readonly MiddlewareObject[], TOutContext>(
+  middlewares: readonly [...T],
+  fn: MiddlewareFunction<Expand<MergeMiddlewareContext<T>>, TOutContext>,
+): MiddlewareObject<any, TOutContext> {
+  return { deps: middlewares, fn: fn as any };
+}
+
+export function createMiddlewareWithGlobalContext<
+  T extends readonly MiddlewareObject[],
+  TOutContext,
+>(
+  middlewares: readonly [...T],
+  fn: MiddlewareFunction<Expand<MergeMiddlewareContext<[...GlobalMiddlewares, ...T]>>, TOutContext>,
+): MiddlewareObject<any, TOutContext> {
+  return createMiddleware(middlewares, fn as any);
+}
+
+export function setGlobalMiddlewares<T extends readonly MiddlewareObject[]>(...middlewares: T) {
+  globalMiddlewares = middlewares;
+  return middlewares;
+}

packages/app-builder/src/entry.server.tsx

@@ -16,6 +16,7 @@ import { initServerServices } from './services/init.server';
 import { captureUnexpectedRemixError } from './services/monitoring';
 import { checkEnv, getClientEnvVars, getServerEnv } from './utils/environment';
 import { NonceProvider } from './utils/nonce';
+import './global-middlewares';
 
 const ABORT_DELAY = 70000;
 

packages/app-builder/src/global-middlewares.ts

@@ -0,0 +1,4 @@
+import { setGlobalMiddlewares } from '@app-builder/core/requests';
+import { servicesMiddleware } from './middlewares/services-middleware';
+
+export const globalMiddlewares = setGlobalMiddlewares(servicesMiddleware);

packages/app-builder/src/middlewares/auth-middleware.ts

@@ -0,0 +1,29 @@
+import { createMiddlewareWithGlobalContext } from '@app-builder/core/requests';
+import { getRoute } from '@app-builder/utils/routes';
+
+export const authMiddleware = createMiddlewareWithGlobalContext(
+  [],
+  async function authMiddleware({ request, context }, next) {
+    const { authSessionService } = context.services;
+    const authSession = await authSessionService.getSession(request);
+
+    const authInfo = await context.services.authService.isAuthenticated(request, {
+      failureRedirect: getRoute('/sign-in'),
+    });
+
+    const res = await next({ context: { authInfo } });
+
+    // Updating the token in the cookies if it has been updated
+    const tokenUpdate = authInfo.tokenService.getUpdate();
+    if (tokenUpdate.status) {
+      const { marbleToken, refreshToken } = tokenUpdate;
+      authSession.set('authToken', marbleToken);
+      if (refreshToken) {
+        authSession.set('refreshToken', refreshToken);
+      }
+      res.__headers.push(['Set-Cookie', await authSessionService.commitSession(authSession)]);
+    }
+
+    return res;
+  },
+);

packages/app-builder/src/middlewares/oidc-middleware.ts

@@ -0,0 +1,11 @@
+import { createMiddlewareWithGlobalContext } from '@app-builder/core/requests';
+
+export const oidcMiddleware = createMiddlewareWithGlobalContext(
+  [],
+  async function oidcMiddleware({ request, context }, next) {
+    const oidc = await context.services.authService.makeOidcService(context.appConfig);
+    const tokens = await oidc.authenticate(request);
+
+    return next({ context: { oidc, oidcTokens: tokens } });
+  },
+);

packages/app-builder/src/middlewares/services-middleware.ts

@@ -0,0 +1,12 @@
+import { createMiddleware } from '@app-builder/core/requests';
+import { initServerServices } from '@app-builder/services/init.server';
+
+export const servicesMiddleware = createMiddleware(
+  [],
+  async function servicesMiddleware({ request }, next) {
+    const services = initServerServices(request);
+    const appConfig = await services.appConfigRepository.getAppConfig();
+
+    return next({ context: { services, appConfig } });
+  },
+);