@jumentix/cli-init 0.0.0

package/templates/backend/src/interface/HTTP/adapters/start-rest-api.ts

@@ -0,0 +1,65 @@
+import { resolveHTTPFramework } from '@src/interface/runtime/RuntimeEnvironment';
+
+/**
+ * Framework name to the module that starts it.
+ *
+ * Importing one of these *is* the side effect — each adapter module boots its
+ * server at evaluation time — so the table holds thunks rather than modules.
+ *
+ * This was eleven near-identical `if` blocks. The mapping is data, and writing
+ * it as data means adding an adapter is one row rather than one more branch a
+ * reader has to compare against the ten above it.
+ *
+ * The thunks are the only unreachable part of this file: a unit test can assert
+ * *which* one was selected — that is what the injected table is for — but never
+ * call it. Hence `ignore next` here, rather than the `ignore file` this carried
+ * before: the file-wide form also hid the loader beneath, so the selection
+ * logic, the unknown-framework error and the default were invisible to coverage
+ * for as long as the pragma covered everything.
+ */
+/* istanbul ignore next -- invoking a thunk boots a real server; see above */
+export const REST_API_ADAPTERS: Readonly<Record<string, () => Promise<unknown>>> = {
+  express: () => import('@src/interface/HTTP/adapters/express/express'),
+  fastify: () => import('@src/interface/HTTP/adapters/fastify/fastify'),
+  restify: () => import('@src/interface/HTTP/adapters/restify/restify'),
+  'cloudflare-workers': () => import('@src/interface/HTTP/adapters/cloudflare-workers/cloudflare-workers'),
+  'vercel-functions': () => import('@src/interface/HTTP/adapters/vercel-functions/vercel-functions'),
+  loopback: () => import('@src/interface/HTTP/adapters/loopback/loopback'),
+  'sails-js': () => import('@src/interface/HTTP/adapters/sails-js/sails-js'),
+  feathers: () => import('@src/interface/HTTP/adapters/feathers/feathers'),
+  'derby-js': () => import('@src/interface/HTTP/adapters/derby-js/derby-js'),
+  'adonis-js': () => import('@src/interface/HTTP/adapters/adonis-js/adonis-js'),
+  'total-js': () => import('@src/interface/HTTP/adapters/total-js/total-js')
+};
+
+/**
+ * @param env Where `JUMENTIX_HTTP_FRAMEWORK` is read from.
+ * @param adapters Injected so a test can observe which adapter was selected
+ * without importing it — importing one starts a real HTTP server. That was
+ * previously arranged by replacing the adapter module with `jest.doMock`, which
+ * does not exist under Bun's runner (JUM-583).
+ */
+export async function startRestApiAdapter(
+  env: NodeJS.ProcessEnv = process.env,
+  adapters: Readonly<Record<string, () => Promise<unknown>>> = REST_API_ADAPTERS
+): Promise<void> {
+  const framework = resolveHTTPFramework(env);
+  const load = adapters[framework];
+
+  // `resolveHTTPFramework` already rejects names it does not know, so reaching
+  // here means the two lists have drifted apart. The previous if-chain returned
+  // silently in that case: no server started, and the caller told it succeeded.
+  if (load === undefined) {
+    throw new Error(
+      `No adapter registered for JUMENTIX_HTTP_FRAMEWORK "${framework}". `
+      + 'RuntimeEnvironment accepts it but REST_API_ADAPTERS has no entry.'
+    );
+  }
+
+  await load();
+}
+
+/* istanbul ignore if */
+if (require.main === module) {
+  startRestApiAdapter();
+}

package/templates/backend/src/interface/HTTP/adapters/total-js/TotalJsServer.ts

@@ -0,0 +1,245 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable class-methods-use-this */
+import { createServer, Server } from 'http';
+import fs from 'fs';
+import path from 'path';
+import { createUuid } from '@src/modules/port/UUID';
+import { _HTTP_PORT_ } from '@src/config/constants';
+import { Context as RequestContext } from '@src/infra/context/Context';
+import type {
+  IHTTPRequest,
+  IHTTPResponse,
+  IbaseHandler
+} from '@src/interface/HTTP/ports';
+import {
+  HTTPBaseServer
+} from '@src/interface/HTTP/ports';
+
+export type TotalJsRequest = IHTTPRequest;
+export type TotalJsResponse = {
+  status: (statusCode: number) => TotalJsResponse;
+  json: (payload: any) => any;
+  send?: (payload: any) => any;
+} & IHTTPResponse;
+
+let totalJsServer: HTTPBaseServer<any> | undefined;
+
+class TotalJsServer extends HTTPBaseServer<any> {
+  public readonly application: any = {};
+
+  private readonly router: any;
+
+  private server: Server | undefined;
+
+  private staticDocs: Record<string, Map<string, string>> = {};
+
+  private staticDocsRegistered = false;
+
+  private static getContentType(fileName: string): string {
+    if (fileName.endsWith('.html')) return 'text/html; charset=utf-8';
+    if (fileName.endsWith('.js')) return 'application/javascript; charset=utf-8';
+    if (fileName.endsWith('.css')) return 'text/css; charset=utf-8';
+    if (fileName.endsWith('.json')) return 'application/json; charset=utf-8';
+    if (fileName.endsWith('.svg')) return 'image/svg+xml';
+    if (fileName.endsWith('.png')) return 'image/png';
+    if (fileName.endsWith('.jpg') || fileName.endsWith('.jpeg')) return 'image/jpeg';
+    return 'text/plain; charset=utf-8';
+  }
+
+  private static normalizeDocRequestPath(rawUrl: string, prefix: string): string {
+    const pathname = rawUrl.split('?')[0];
+    const trimmed = pathname.startsWith(prefix) ? pathname.slice(prefix.length) : pathname;
+    const candidate = trimmed.replace(/^\/+/, '') || 'index.html';
+    const normalized = path.posix.normalize(`/${candidate}`).replace(/^\/+/, '');
+    if (!normalized || normalized.includes('..')) return '';
+    return normalized;
+  }
+
+  private loadStaticDocManifest(docFolder: string): Map<string, string> {
+    const manifest = new Map<string, string>();
+    const absoluteFolder = path.resolve(process.cwd(), docFolder);
+    if (!fs.existsSync(absoluteFolder)) return manifest;
+
+    const walk = (currentPath: string) => {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+      entries.forEach((entry) => {
+        const absoluteEntryPath = path.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+          walk(absoluteEntryPath);
+          return;
+        }
+        const relative = path.relative(absoluteFolder, absoluteEntryPath).split(path.sep).join('/');
+        manifest.set(relative, absoluteEntryPath);
+      });
+    };
+
+    walk(absoluteFolder);
+    return manifest;
+  }
+
+  constructor() {
+    super();
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    const Router = require('find-my-way');
+    this.router = Router();
+
+    // Prime Total.js package if installed (optional, runtime-pluggable).
+    try {
+      // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+      this.application.total = require('total4');
+    } catch (error) {
+      this.application.total = null;
+    }
+  }
+
+  private createResponseAdapter(response: any): any {
+    return {
+      status(code: number) {
+        response.statusCode = code;
+        return this;
+      },
+      json(payload: any) {
+        response.setHeader('content-type', 'application/json; charset=utf-8');
+        response.end(JSON.stringify(payload));
+        return payload;
+      },
+      send(payload: any) {
+        if (typeof payload === 'object') {
+          response.setHeader('content-type', 'application/json; charset=utf-8');
+          response.end(JSON.stringify(payload));
+          return payload;
+        }
+        response.end(payload);
+        return payload;
+      }
+    };
+  }
+
+  private async readBody(request: any): Promise<any> {
+    const method = (request.method || 'GET').toUpperCase();
+    if (method === 'GET' || method === 'HEAD') return {};
+
+    const chunks: Buffer[] = [];
+    await new Promise<void>((resolve, reject) => {
+      request.on('data', (chunk: Buffer | string) => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      request.on('end', () => resolve());
+      request.on('error', (error: Error) => reject(error));
+    });
+
+    if (!chunks.length) return {};
+    const raw = Buffer.concat(chunks).toString('utf8').trim();
+    if (!raw) return {};
+
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+
+  public endPointRegister(handlerFactory: IbaseHandler): void {
+    this.router.on(
+      handlerFactory.method.toUpperCase(),
+      handlerFactory.path,
+      async (request: any, response: any, params: Record<string, any>) => {
+        const body = await this.readBody(request);
+        const req = {
+          ...request,
+          params,
+          query: request.query || {},
+          headers: request.headers || {},
+          body
+        };
+        const res = this.createResponseAdapter(response);
+        await handlerFactory.handler(req, res);
+      }
+    );
+  }
+
+  private registerStaticDocsRoutes(): void {
+    this.staticDocs.OASdoc = this.loadStaticDocManifest('apps/backend-template/OASdoc');
+    this.staticDocs.AsyncAPIdoc = this.loadStaticDocManifest('apps/backend-template/AsyncAPIdoc');
+    const register = (prefix: string, docFolder: string) => {
+      const manifestKey = prefix.replace('/', '');
+      this.router.on('GET', `${prefix}/*`, async (request: any, response: any) => {
+        const normalizedPath = TotalJsServer.normalizeDocRequestPath(request.url || '', prefix);
+        const manifest = this.staticDocs[manifestKey] || this.loadStaticDocManifest(docFolder);
+        const absolutePath = normalizedPath ? manifest.get(normalizedPath) : undefined;
+        if (!absolutePath || !fs.existsSync(absolutePath)) {
+          response.statusCode = 404;
+          response.end('Not found');
+          return;
+        }
+        response.statusCode = 200;
+        response.setHeader('content-type', TotalJsServer.getContentType(absolutePath));
+        response.end(fs.readFileSync(absolutePath));
+      });
+    };
+
+    register('/OASdoc', 'apps/backend-template/OASdoc');
+    register('/AsyncAPIdoc', 'apps/backend-template/AsyncAPIdoc');
+    this.router.on('GET', '/docs/asyncapi', async (_request: any, response: any) => {
+      response.statusCode = 302;
+      response.setHeader('location', '/AsyncAPIdoc');
+      response.end();
+    });
+  }
+
+  /**
+   * The listener `start` binds, exposed so a test can drive it (JUM-698).
+   *
+   * Extracted rather than invented: `start` used to build this inline and then
+   * bind it to a fixed port, which is why the suite named after this adapter
+   * never went near it. A suite that binds `_HTTP_PORT_` is also a suite that
+   * fails when anything else on the machine holds it (Requirement 134 §1).
+   */
+  public requestListener(): (req: any, res: any) => void {
+    if (!this.staticDocsRegistered) {
+      this.registerStaticDocsRoutes();
+      this.staticDocsRegistered = true;
+    }
+
+    /*
+     * The per-request store every handler reads. Express, Restify, Fastify and
+     * Lambda each establish it; this adapter did not, and it serves the same
+     * handlers — `localhost.get` reads `correlationId` from the store, so every
+     * request through it answered 500 with an empty message.
+     */
+    return (req: any, res: any) => {
+      const store = new Map();
+      RequestContext.run(store, () => {
+        store.set('correlationId', createUuid());
+        store.set('timeStart', +new Date());
+        store.set('request', req);
+        store.set('authorization', req.headers?.authorization || '');
+        this.router.lookup(req, res);
+      });
+    };
+  }
+
+  public async start(): Promise<void> {
+    this.server = createServer(this.requestListener());
+    await new Promise<void>((resolve) => {
+      this.server!.listen(_HTTP_PORT_, resolve);
+    });
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.server) return;
+    await new Promise<void>((resolve) => {
+      this.server!.close(() => resolve());
+    });
+  }
+
+  public static compile(): HTTPBaseServer<any> {
+    if (!totalJsServer) {
+      totalJsServer = new TotalJsServer();
+    }
+    return totalJsServer;
+  }
+}
+
+export { TotalJsServer };

package/templates/backend/src/interface/HTTP/adapters/total-js/handlers/infraHandlers.ts

@@ -0,0 +1,3 @@
+import { infraHandlers as expressInfraHandlers } from '@src/interface/HTTP/adapters/express/handlers/infraHandlers';
+
+export const infraHandlers = expressInfraHandlers;

package/templates/backend/src/interface/HTTP/adapters/total-js/responses/sendErrorResponse.ts

@@ -0,0 +1,9 @@
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+import { buildErrorResponsePayload, toHttpStatus } from '@src/shared/utils';
+import type { TotalJsResponse } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+
+export function sendErrorResponse(error: BaseError, res: TotalJsResponse) {
+  return res
+    .status(toHttpStatus(error.code as EErrorStringCodes) || 500)
+    .json(buildErrorResponsePayload(error));
+}

package/templates/backend/src/interface/HTTP/adapters/total-js/total-js.ts

@@ -0,0 +1,55 @@
+/* eslint-disable quote-props */
+import { TotalJsServer } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/total-js/handlers/infraHandlers';
+
+import {
+  composeUsersAuthServices
+} from '@src/modules/Users';
+
+import { MutexService } from '@src/infra/mutex/adapter/MutexService';
+import { compileDatabaseClient } from '@src/infra/persistence/compileDatabaseClient';
+import { JwtService } from '@src/infra/jwt/JwtService';
+import { compileKeyValueStorageClient } from '@src/infra/persistence/KeyValueStorage/compileKeyValueStorageClient';
+import { PasswordCryptoService } from '@src/infra/security/PasswordCryptoService';
+import { compileMessageMediator } from '@src/infra/messages/compileMessageMediator';
+import { EHTTPFrameworks } from '@src/interface/HTTP/ports';
+import { RestAPI } from '@src/interface/HTTP/RestAPI';
+import { compileAdapterRuntime } from '@jumentix/adapter-runtime-bootstrap';
+
+const serverType = EHTTPFrameworks.total_js;
+const webServer = TotalJsServer.compile();
+
+const {
+  databaseClient,
+  keyValueStorageClient,
+  mutexService,
+  passwordCryptoService,
+  messageMediator,
+  authService
+} = compileAdapterRuntime({
+  compileDatabaseClient,
+  compileKeyValueStorageClient,
+  compileMutexService: (client) => MutexService.compile(client),
+  compilePasswordCryptoService: () => PasswordCryptoService.compile(),
+  compileJwtService: () => JwtService.compile(),
+  compileMessageMediator: () => compileMessageMediator(),
+  composeAuthServices: composeUsersAuthServices
+});
+
+const API = new RestAPI<any>({
+  databaseClient,
+  webServer,
+  infraHandlers,
+  serverType,
+  authService,
+  passwordCryptoService,
+  keyValueStorageClient,
+  mutexService,
+  eventBus: messageMediator,
+  messageMediator
+});
+
+(async () => {
+  await API.start();
+  await API.seedData();
+})();

package/templates/backend/src/interface/HTTP/adapters/vercel-functions/responses/sendErrorResponse.ts

@@ -0,0 +1,9 @@
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+import { buildErrorResponsePayload, toHttpStatus } from '@src/shared/utils';
+import type { VercelFunctionsResponse } from '@src/interface/HTTP/adapters/vercel-functions/vercel-functions';
+
+export function sendErrorResponse(error: BaseError, res: VercelFunctionsResponse) {
+  return res
+    .status(toHttpStatus(error.code as EErrorStringCodes) || 500)
+    .json(buildErrorResponsePayload(error));
+}

package/templates/backend/src/interface/HTTP/adapters/vercel-functions/vercel-functions.ts

@@ -0,0 +1,252 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { createUuid } from '@src/modules/port/UUID';
+
+import { RestAPI } from '@src/interface/HTTP/RestAPI';
+import { Context as RequestContext } from '@src/infra/context/Context';
+import type {
+  IHTTPRequest,
+  IHTTPResponse,
+  IbaseHandler
+} from '@src/interface/HTTP/ports';
+import {
+  EHTTPFrameworks,
+  HTTPBaseServer
+} from '@src/interface/HTTP/ports';
+import { infraHandlers } from '@src/interface/HTTP/adapters/express/handlers/infraHandlers';
+import { compileMessageMediator } from '@src/infra/messages/compileMessageMediator';
+import { compileDatabaseClient } from '@src/infra/persistence/compileDatabaseClient';
+import { compileKeyValueStorageClient } from '@src/infra/persistence/KeyValueStorage/compileKeyValueStorageClient';
+import { JwtService } from '@src/infra/jwt/JwtService';
+import { MutexService } from '@src/infra/mutex/adapter/MutexService';
+import { PasswordCryptoService } from '@src/infra/security/PasswordCryptoService';
+import { composeUsersAuthServices } from '@src/modules/Users';
+import { compileAdapterRuntime } from '@jumentix/adapter-runtime-bootstrap';
+import {
+  escapeText,
+  isStaticDocsPath,
+  STATIC_DOCS_UNAVAILABLE_MESSAGE
+} from './vercelFunctionsSecurity';
+
+type RouteMatch = {
+  matched: boolean;
+  params: Record<string, string>;
+};
+
+type RegisteredRoute = {
+  method: string;
+  path: string;
+  handler: IbaseHandler['handler'];
+};
+
+type VercelRequest = {
+  method?: string;
+  url?: string;
+  headers: Record<string, string | string[] | number | undefined>;
+  body?: unknown;
+};
+
+type VercelResponse = {
+  writableEnded?: boolean;
+  setHeader: (key: string, value: string) => void;
+  status: (statusCode: number) => VercelResponse;
+  json: (payload: any) => any;
+  send: (payload: any) => any;
+  end: () => void;
+};
+
+export type VercelFunctionsRequest = IHTTPRequest;
+export type VercelFunctionsResponse = {
+  status: (statusCode: number) => VercelFunctionsResponse;
+  json: (payload: any) => any;
+  send?: (payload: any) => any;
+} & IHTTPResponse;
+
+class VercelFunctionsServer extends HTTPBaseServer<Record<string, never>> {
+  private static instance: any;
+
+  public readonly application: Record<string, never> = {};
+
+  private readonly routes: RegisteredRoute[] = [];
+
+  private static tryServeStaticDoc(pathname: string, res: VercelResponse): boolean {
+    if (!isStaticDocsPath(pathname)) return false;
+    res.status(501).json({
+      message: STATIC_DOCS_UNAVAILABLE_MESSAGE
+    });
+    return true;
+  }
+
+  public endPointRegister(handlerFactory: IbaseHandler): void {
+    this.routes.push({
+      method: handlerFactory.method.toUpperCase(),
+      path: handlerFactory.path,
+      handler: handlerFactory.handler
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  public async start(): Promise<void> {
+    // Vercel Functions runs per request, no process listener.
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  public async stop(): Promise<void> {
+    // no-op
+  }
+
+  private static matchPath(template: string, value: string): RouteMatch {
+    const templateParts = template.split('/').filter(Boolean);
+    const valueParts = value.split('/').filter(Boolean);
+    if (templateParts.length !== valueParts.length) {
+      return { matched: false, params: {} };
+    }
+
+    const params: Record<string, string> = {};
+    for (let i = 0; i < templateParts.length; i += 1) {
+      const [templatePart, valuePart] = [templateParts[i], valueParts[i]];
+
+      if (templatePart.startsWith(':')) {
+        params[templatePart.slice(1)] = decodeURIComponent(valuePart);
+      } else if (templatePart !== valuePart) {
+        return { matched: false, params: {} };
+      }
+    }
+
+    return { matched: true, params };
+  }
+
+  private static getUrl(req: VercelRequest): URL {
+    const protocol = 'https';
+    const host = 'localhost';
+    const requestPath = req.url || '/';
+    return new URL(`${protocol}://${host}${requestPath}`);
+  }
+
+  /**
+   * The per-request store every handler reads (JUM-698).
+   *
+   * Express, Restify, Fastify and Lambda each establish this; this adapter did
+   * not, and it registers the same `infraHandlers`. `localhost.get` calls
+   * `Context.getStore().get('correlationId')`, so **every request through this
+   * function answered 500** with an empty message. The suite named after this
+   * adapter hid it by calling an Express handler directly and running
+   * `Context.run` itself — supplying the very thing that was missing.
+   */
+  public async handle(req: VercelRequest, res: VercelResponse): Promise<void> {
+    const store = new Map();
+    return RequestContext.run(store, () => {
+      store.set('correlationId', createUuid());
+      store.set('timeStart', +new Date());
+      store.set('request', req);
+      store.set('authorization', req.headers.authorization || '');
+      return this.route(req, res);
+    });
+  }
+
+  private async route(req: VercelRequest, res: VercelResponse): Promise<void> {
+    const url = VercelFunctionsServer.getUrl(req);
+    const { pathname } = url;
+    const method = (req.method || 'GET').toUpperCase();
+
+    if (pathname === '/docs/asyncapi') {
+      res.status(302).setHeader('location', '/AsyncAPIdoc');
+      res.end();
+      return;
+    }
+    if (VercelFunctionsServer.tryServeStaticDoc(pathname, res)) {
+      return;
+    }
+
+    const matched = this.routes
+      .map((route) => ({ route, match: VercelFunctionsServer.matchPath(route.path, pathname) }))
+      .find((candidate) => candidate.route.method === method && candidate.match.matched);
+
+    if (!matched) {
+      res.status(404).json({ message: 'Not found' });
+      return;
+    }
+
+    const headers: Record<string, string> = {};
+    Object.entries(req.headers).forEach(([key, value]) => {
+      if (Array.isArray(value)) headers[key] = value.join(',');
+      else if (typeof value === 'string') headers[key] = value;
+      else if (typeof value === 'number') headers[key] = `${value}`;
+    });
+
+    const frameworkReq = {
+      ...req,
+      params: matched.match.params,
+      query: Object.fromEntries(url.searchParams.entries()),
+      headers,
+      body: req.body
+    } as unknown as VercelFunctionsRequest;
+
+    const frameworkRes = res as unknown as VercelFunctionsResponse;
+    const result = await matched.route.handler(frameworkReq, frameworkRes);
+
+    if (result !== undefined && !res.writableEnded) {
+      if (typeof result === 'string') {
+        res.status(200).json({ message: escapeText(result) });
+        return;
+      }
+      res.status(200).json(result);
+    }
+  }
+
+  public static compile(): VercelFunctionsServer {
+    if (!VercelFunctionsServer.instance) {
+      VercelFunctionsServer.instance = new VercelFunctionsServer();
+    }
+    return VercelFunctionsServer.instance;
+  }
+}
+
+const serverType = EHTTPFrameworks.vercel_functions;
+const webServer = VercelFunctionsServer.compile();
+const {
+  databaseClient,
+  keyValueStorageClient,
+  mutexService,
+  passwordCryptoService,
+  messageMediator,
+  authService
+} = compileAdapterRuntime({
+  compileDatabaseClient,
+  compileKeyValueStorageClient,
+  compileMutexService: (client) => MutexService.compile(client),
+  compilePasswordCryptoService: () => PasswordCryptoService.compile(),
+  compileJwtService: () => JwtService.compile(),
+  compileMessageMediator: () => compileMessageMediator(),
+  composeAuthServices: composeUsersAuthServices
+});
+
+const API = new RestAPI<Record<string, never>>({
+  databaseClient,
+  webServer,
+  infraHandlers,
+  serverType,
+  authService,
+  passwordCryptoService,
+  keyValueStorageClient,
+  mutexService,
+  eventBus: messageMediator,
+  messageMediator
+});
+
+let initialized: Promise<void> | undefined;
+
+const ensureInitialized = async (): Promise<void> => {
+  if (!initialized) {
+    initialized = (async () => {
+      await API.start();
+      await API.seedData();
+    })();
+  }
+  await initialized;
+};
+
+export default async function handler(req: VercelRequest, res: VercelResponse): Promise<void> {
+  await ensureInitialized();
+  await webServer.handle(req, res);
+}

package/templates/backend/src/interface/HTTP/adapters/vercel-functions/vercelFunctionsSecurity.ts

@@ -0,0 +1,14 @@
+export const STATIC_DOCS_UNAVAILABLE_MESSAGE = 'Static docs are not served by this serverless adapter. Use the primary REST API docs endpoint.';
+
+export const isStaticDocsPath = (pathname: string): boolean => {
+  return pathname.startsWith('/OASdoc') || pathname.startsWith('/AsyncAPIdoc');
+};
+
+export const escapeText = (value: string): string => {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+};