@jumentix/cli-init 0.0.0

package/templates/backend/src/interface/HTTP/adapters/adonis-js/AdonisJsServer.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 AdonisJsRequest = IHTTPRequest;
+export type AdonisJsResponse = {
+  status: (statusCode: number) => AdonisJsResponse;
+  json: (payload: any) => any;
+  send?: (payload: any) => any;
+} & IHTTPResponse;
+
+let adonisJsServer: HTTPBaseServer<any> | undefined;
+
+class AdonisJsServer 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 Adonis HTTP package if installed (kept optional for modular usage).
+    try {
+      // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+      this.application.http = require('@adonisjs/http-server');
+    } catch (error) {
+      this.application.http = 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 = AdonisJsServer.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', AdonisJsServer.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 (!adonisJsServer) {
+      adonisJsServer = new AdonisJsServer();
+    }
+    return adonisJsServer;
+  }
+}
+
+export { AdonisJsServer };

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

@@ -0,0 +1,55 @@
+/* eslint-disable quote-props */
+import { AdonisJsServer } from '@src/interface/HTTP/adapters/adonis-js/AdonisJsServer';
+import { infraHandlers } from '@src/interface/HTTP/adapters/adonis-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.adonis_js;
+const webServer = AdonisJsServer.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/adonis-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/adonis-js/responses/sendErrorResponse.ts

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

package/templates/backend/src/interface/HTTP/adapters/aws/lambda/handlers/localhost.ts

@@ -0,0 +1,12 @@
+import type { Handler, APIGatewayProxyResult } from 'aws-lambda';
+
+export const handler: Handler = async ():
+Promise<APIGatewayProxyResult> => {
+  // console.log(event);
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ status: 'result' })
+  };
+};
+
+export const getHandler = handler;

package/templates/backend/src/interface/HTTP/adapters/aws/lambda/responses/sendErrorResponse.ts

@@ -0,0 +1,9 @@
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+import { buildErrorResponsePayload, toHttpStatus } from '@src/shared/utils';
+
+export function sendErrorResponse(error: BaseError) {
+  return {
+    statusCode: toHttpStatus(error.code as EErrorStringCodes) || 500,
+    body: JSON.stringify(buildErrorResponsePayload(error))
+  };
+}

package/templates/backend/src/interface/HTTP/adapters/cloudflare-workers/cloudflare-workers.ts

@@ -0,0 +1,277 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Hono } from 'hono';
+import type { Context } from 'hono';
+import fs from 'fs';
+import path from 'path';
+import { createUuid } from '@src/modules/port/UUID';
+
+import { RestAPI } from '@src/interface/HTTP/RestAPI';
+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 { Context as RequestContext } from '@src/infra/context/Context';
+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';
+
+type HonoRouteMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options' | 'head';
+
+export type CloudflareWorkersRequest = IHTTPRequest;
+export type CloudflareWorkersResponse = {
+  status: (statusCode: number) => CloudflareWorkersResponse;
+  json: (payload: any) => any;
+  send?: (payload: any) => any;
+} & IHTTPResponse;
+
+class CloudflareWorkersServer extends HTTPBaseServer<Hono> {
+  private static instance: any;
+
+  public readonly application: Hono;
+
+  constructor() {
+    super();
+    this.application = new Hono();
+    this.registerRequestContext();
+    this.registerStaticDocsRoutes();
+  }
+
+  /**
+   * 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 the
+   * worker answered 500** with an empty message. Nothing caught it because the
+   * suite named after this adapter called an Express handler directly and ran
+   * `Context.run` itself — the test supplied the very thing that was missing.
+   */
+  private registerRequestContext(): void {
+    this.application.use(async (c: Context, next) => {
+      const store = new Map();
+      return RequestContext.run(store, () => {
+        store.set('correlationId', createUuid());
+        store.set('timeStart', +new Date());
+        store.set('request', c.req);
+        store.set('authorization', c.req.header('authorization') || '');
+        return next();
+      });
+    });
+  }
+
+  private registerStaticDocsRoutes(): void {
+    const rootDir = process.cwd();
+    const getType = (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';
+      return 'text/plain; charset=utf-8';
+    };
+    const register = (prefix: string, folder: string) => {
+      this.application.get(`${prefix}/*`, async (c: Context) => {
+        const relative = c.req.path.replace(`${prefix}/`, '') || 'index.html';
+        const absolute = path.join(rootDir, folder, relative);
+        if (!fs.existsSync(absolute)) {
+          return c.json({ message: 'Not found' }, 404);
+        }
+        const content = fs.readFileSync(absolute);
+        return c.newResponse(content, 200, {
+          'content-type': getType(absolute)
+        });
+      });
+    };
+    register('/OASdoc', 'apps/backend-template/OASdoc');
+    register('/AsyncAPIdoc', 'apps/backend-template/AsyncAPIdoc');
+    this.application.get('/docs/asyncapi', async (c: Context) => {
+      return c.redirect('/AsyncAPIdoc', 302);
+    });
+  }
+
+  private static normalizeBody(raw: string): any {
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+
+  private static async parseBody(c: Context): Promise<any> {
+    const method = c.req.method.toUpperCase();
+    if (method === 'GET' || method === 'HEAD') {
+      return {};
+    }
+    const raw = await c.req.text();
+    return CloudflareWorkersServer.normalizeBody(raw);
+  }
+
+  private static buildRequest(
+    c: Context,
+    params: Record<string, string>,
+    body: any
+  ): CloudflareWorkersRequest {
+    const headers = Object.fromEntries(c.req.raw.headers.entries());
+    return {
+      params,
+      query: c.req.query(),
+      headers,
+      body,
+      method: c.req.method,
+      url: c.req.url
+    } as unknown as CloudflareWorkersRequest;
+  }
+
+  private static createResponseAdapter(c: Context) {
+    const state = {
+      statusCode: 200,
+      body: undefined as any,
+      contentType: 'application/json; charset=utf-8',
+      sent: false
+    };
+
+    const response: CloudflareWorkersResponse = {
+      status(code: number) {
+        state.statusCode = code;
+        return response;
+      },
+      json(payload: any) {
+        state.body = JSON.stringify(payload);
+        state.contentType = 'application/json; charset=utf-8';
+        state.sent = true;
+        return payload;
+      },
+      send(payload: any) {
+        if (typeof payload === 'string') {
+          state.body = payload;
+          state.contentType = 'text/plain; charset=utf-8';
+        } else {
+          state.body = JSON.stringify(payload);
+          state.contentType = 'application/json; charset=utf-8';
+        }
+        state.sent = true;
+        return payload;
+      }
+    } as CloudflareWorkersResponse;
+
+    const finalize = (handlerResult: any): Response => {
+      if (handlerResult instanceof Response) return handlerResult;
+
+      if (state.sent) {
+        return c.newResponse(state.body, state.statusCode as any, {
+          'content-type': state.contentType
+        });
+      }
+
+      if (handlerResult !== undefined) {
+        if (typeof handlerResult === 'string') {
+          return c.newResponse(handlerResult, state.statusCode as any, {
+            'content-type': 'text/plain; charset=utf-8'
+          });
+        }
+        return c.json(handlerResult, state.statusCode as any);
+      }
+
+      return c.newResponse(null, 204);
+    };
+
+    return { response, finalize };
+  }
+
+  public endPointRegister(handlerFactory: IbaseHandler): void {
+    const method = handlerFactory.method.toLowerCase() as HonoRouteMethod;
+    (this.application as any)[method](handlerFactory.path, async (c: Context) => {
+      const params = c.req.param();
+      const body = await CloudflareWorkersServer.parseBody(c);
+      const req = CloudflareWorkersServer.buildRequest(c, params, body);
+      const { response, finalize } = CloudflareWorkersServer.createResponseAdapter(c);
+      const result = await handlerFactory.handler(req, response);
+      return finalize(result);
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  public async start(): Promise<void> {
+    // Cloudflare Workers is request-driven.
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  public async stop(): Promise<void> {
+    // no-op
+  }
+
+  public static compile(): CloudflareWorkersServer {
+    if (!CloudflareWorkersServer.instance) {
+      CloudflareWorkersServer.instance = new CloudflareWorkersServer();
+    }
+    return CloudflareWorkersServer.instance;
+  }
+}
+
+const serverType = EHTTPFrameworks.cloudflare_workers;
+const webServer = CloudflareWorkersServer.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<Hono>({
+  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 const fetch = async (
+  request: Request,
+  env?: Record<string, any>,
+  executionCtx?: any
+): Promise<Response> => {
+  await ensureInitialized();
+  return webServer.application.fetch(request, env, executionCtx);
+};
+
+export default {
+  fetch
+};

package/templates/backend/src/interface/HTTP/adapters/cloudflare-workers/responses/sendErrorResponse.ts

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