chore: rename fundamentals to base (#9119)

packages/backend/server/src/base/utils/promise.ts

@@ -0,0 +1,50 @@
+import { defer as rxjsDefer, retry } from 'rxjs';
+
+export class RetryablePromise<T> extends Promise<T> {
+  constructor(
+    executor: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: any) => void
+    ) => void,
+    retryTimes: number = 3,
+    retryIntervalInMs: number = 300
+  ) {
+    super((resolve, reject) => {
+      rxjsDefer(() => new Promise<T>(executor))
+        .pipe(
+          retry({
+            count: retryTimes,
+            delay: retryIntervalInMs,
+          })
+        )
+        .subscribe({
+          next: v => {
+            resolve(v);
+          },
+          error: e => {
+            reject(e);
+          },
+        });
+    });
+  }
+}
+
+export function retryable<Ret = unknown>(
+  asyncFn: () => Promise<Ret>,
+  retryTimes = 3,
+  retryIntervalInMs = 300
+): Promise<Ret> {
+  return new RetryablePromise<Ret>(
+    (resolve, reject) => {
+      asyncFn().then(resolve).catch(reject);
+    },
+    retryTimes,
+    retryIntervalInMs
+  );
+}
+
+export function defer(dispose: () => Promise<void>) {
+  return {
+    [Symbol.asyncDispose]: dispose,
+  };
+}

packages/backend/server/src/base/utils/request.ts

@@ -0,0 +1,79 @@
+import { IncomingMessage } from 'node:http';
+
+import type { ArgumentsHost, ExecutionContext } from '@nestjs/common';
+import type { GqlContextType } from '@nestjs/graphql';
+import { GqlArgumentsHost } from '@nestjs/graphql';
+import type { Request, Response } from 'express';
+import type { Socket } from 'socket.io';
+
+export function getRequestResponseFromHost(host: ArgumentsHost) {
+  switch (host.getType<GqlContextType>()) {
+    case 'graphql': {
+      const gqlContext = GqlArgumentsHost.create(host).getContext<{
+        req: Request;
+      }>();
+      return {
+        req: gqlContext.req,
+        res: gqlContext.req.res,
+      };
+    }
+    case 'http': {
+      const http = host.switchToHttp();
+      return {
+        req: http.getRequest<Request>(),
+        res: http.getResponse<Response>(),
+      };
+    }
+    case 'ws': {
+      const ws = host.switchToWs();
+      const req = ws.getClient<Socket>().request as Request;
+      parseCookies(req);
+      return { req };
+    }
+    case 'rpc': {
+      const rpc = host.switchToRpc();
+      const { req } = rpc.getContext<{ req: Request }>();
+
+      return {
+        req,
+        res: req.res,
+      };
+    }
+  }
+}
+
+export function getRequestFromHost(host: ArgumentsHost) {
+  return getRequestResponseFromHost(host).req;
+}
+
+export function getRequestResponseFromContext(ctx: ExecutionContext) {
+  return getRequestResponseFromHost(ctx);
+}
+
+/**
+ * simple patch for request not protected by `cookie-parser`
+ * only take effect if `req.cookies` is not defined
+ */
+export function parseCookies(
+  req: IncomingMessage & { cookies?: Record<string, string> }
+) {
+  if (req.cookies) {
+    return;
+  }
+
+  const cookieStr = req.headers.cookie ?? '';
+  req.cookies = cookieStr.split(';').reduce(
+    (cookies, cookie) => {
+      const [key, val] = cookie.split('=');
+
+      if (key) {
+        cookies[decodeURIComponent(key.trim())] = val
+          ? decodeURIComponent(val.trim())
+          : val;
+      }
+
+      return cookies;
+    },
+    {} as Record<string, string>
+  );
+}

packages/backend/server/src/base/utils/types.ts

@@ -0,0 +1,53 @@
+import { Readable } from 'node:stream';
+
+export function ApplyType<T>(): ConstructorOf<T> {
+  // @ts-expect-error used to fake the type of config
+  return class Inner implements T {
+    constructor() {}
+  };
+}
+
+export type PathType<T, Path extends string> =
+  T extends Record<string, any>
+    ? string extends Path
+      ? unknown
+      : Path extends keyof T
+        ? T[Path]
+        : Path extends `${infer K}.${infer R}`
+          ? K extends keyof T
+            ? PathType<T[K], R>
+            : unknown
+          : unknown
+    : unknown;
+
+export type Join<Prefix, Suffixes> = Prefix extends string | number
+  ? Suffixes extends string | number
+    ? Prefix extends ''
+      ? Suffixes
+      : `${Prefix}.${Suffixes}`
+    : never
+  : never;
+
+export type LeafPaths<
+  T,
+  Path extends string = '',
+  MaxDepth extends string = '.....',
+  Depth extends string = '',
+> = Depth extends MaxDepth
+  ? never
+  : T extends Record<string | number, any>
+    ? {
+        [K in keyof T]-?: K extends string | number
+          ? T[K] extends PrimitiveType
+            ? K
+            : Join<K, LeafPaths<T[K], Path, MaxDepth, `${Depth}.`>>
+          : never;
+      }[keyof T]
+    : never;
+
+export interface FileUpload {
+  filename: string;
+  mimetype: string;
+  encoding: string;
+  createReadStream: () => Readable;
+}