@jumentix/cli-init 0.0.0

package/templates/backend/src/interface/gRPC/resolveGrpcProtoPath.ts

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import path from 'path';
+
+const CANONICAL_PROTO_SEGMENTS = ['spec', 'asyncapi', 'async-api.proto'];
+
+const findCanonicalProtoFrom = (moduleDirectory: string): string | undefined => {
+  let directory = path.resolve(moduleDirectory);
+  let previousDirectory: string | undefined;
+
+  while (directory !== previousDirectory) {
+    const candidate = path.join(directory, ...CANONICAL_PROTO_SEGMENTS);
+    if (fs.existsSync(candidate)) return candidate;
+
+    previousDirectory = directory;
+    directory = path.dirname(directory);
+  }
+
+  return undefined;
+};
+
+export const resolveGrpcProtoPath = (
+  explicitPath?: string,
+  moduleDirectory = __dirname
+): string => {
+  if (explicitPath) {
+    const resolvedExplicitPath = path.resolve(explicitPath);
+    if (fs.existsSync(resolvedExplicitPath)) return resolvedExplicitPath;
+    throw new Error(
+      `gRPC proto file not found at configured path: ${resolvedExplicitPath}`
+    );
+  }
+
+  const canonicalPath = findCanonicalProtoFrom(moduleDirectory);
+  if (canonicalPath) return canonicalPath;
+
+  throw new Error(
+    `Canonical gRPC proto artifact "${CANONICAL_PROTO_SEGMENTS.join('/')}" `
+    + `was not found from module directory: ${path.resolve(moduleDirectory)}`
+  );
+};
+
+export default resolveGrpcProtoPath;

package/templates/backend/src/interface/runtime/RuntimeEnvironment.ts

@@ -0,0 +1,77 @@
+/* istanbul ignore file */
+export type HTTPFramework =
+  | 'express'
+  | 'fastify'
+  | 'restify'
+  | 'cloudflare-workers'
+  | 'vercel-functions'
+  | 'loopback'
+  | 'sails-js'
+  | 'feathers'
+  | 'derby-js'
+  | 'adonis-js'
+  | 'total-js';
+
+export type RealtimeApiProtocol = 'websocket' | 'grpc';
+
+const DEFAULT_HTTP_FRAMEWORK: HTTPFramework = 'express';
+const DEFAULT_REALTIME_PROTOCOL: RealtimeApiProtocol = 'websocket';
+
+function normalize(value: string | undefined): string {
+  return String(value || '').trim().toLowerCase();
+}
+
+/** Prefer JUMENTIX_*; fall back to legacy AAA_* during env migration. */
+export function readProductEnv(
+  env: NodeJS.ProcessEnv,
+  key: `JUMENTIX_${string}`
+): string | undefined {
+  const value = env[key];
+  // Whitespace-only counts as unset so legacy AAA_* can still apply.
+  if (value !== undefined && value.trim() !== '') return value;
+  return env[key.replace(/^JUMENTIX_/, 'AAA_')];
+}
+
+export function resolveHTTPFramework(env: NodeJS.ProcessEnv = process.env): HTTPFramework {
+  const raw = readProductEnv(env, 'JUMENTIX_HTTP_FRAMEWORK');
+  const framework = normalize(raw) || DEFAULT_HTTP_FRAMEWORK;
+  if (
+    framework === 'express'
+    || framework === 'fastify'
+    || framework === 'restify'
+    || framework === 'cloudflare-workers'
+    || framework === 'vercel-functions'
+    || framework === 'loopback'
+    || framework === 'sails-js'
+    || framework === 'feathers'
+    || framework === 'derby-js'
+    || framework === 'adonis-js'
+    || framework === 'total-js'
+  ) return framework;
+  throw new Error(
+    `Unsupported JUMENTIX_HTTP_FRAMEWORK "${raw}".`
+  );
+}
+
+export function isRealtimeApiEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return normalize(readProductEnv(env, 'JUMENTIX_REALTIME_API') || 'no') === 'yes';
+}
+
+export function resolveRealtimeApiProtocol(
+  env: NodeJS.ProcessEnv = process.env
+): RealtimeApiProtocol {
+  const raw = readProductEnv(env, 'JUMENTIX_REALTIME_API_PROTOCOL');
+  const protocol = normalize(raw) || DEFAULT_REALTIME_PROTOCOL;
+  if (protocol === 'websocket' || protocol === 'grpc') return protocol;
+  throw new Error(
+    `Unsupported JUMENTIX_REALTIME_API_PROTOCOL "${raw}". Supported: websocket, grpc.`
+  );
+}
+
+export function shouldStartRealtimeApi(
+  expectedProtocol: RealtimeApiProtocol,
+  env: NodeJS.ProcessEnv = process.env
+): boolean {
+  if (!isRealtimeApiEnabled(env)) return false;
+  return resolveRealtimeApiProtocol(env) === expectedProtocol;
+}

package/templates/backend/src/modules/Users/adapters/in/http/controllers/AuthController.ts

@@ -0,0 +1,96 @@
+import type { IController, IControllerFactory } from '@src/interface/HTTP/ports';
+import { BaseController } from '@src/interface/HTTP/ports/BaseController';
+import {
+  validateRequestAgainstOAS
+} from '@src/interface/HTTP/validators';
+// import { Security } from '@src/infra/security';
+
+import { BaseDomainEvent } from '@src/modules/port/BaseDomainEvent';
+import type { IServiceResponse } from '@src/modules/port';
+
+import { Authorize } from '@src/shared/decorators/guard/Authorize';
+
+import {
+  EAuthSchemaType
+} from '@src/modules/Users/service/ports/EAuthSchemaType';
+import type { IAuthorizationHeader } from '@src/modules/Users/service/ports/IAuthorizationHeader';
+import type { ILogoutRequest } from '@src/modules/Users/interface/dto/ILogoutRequest';
+import type { ILoginRequest } from '@src/modules/Users/interface/dto/ILoginRequest';
+import type { IUpdatePasswordRequest } from '@src/modules/Users/interface/dto/IUpdatePasswordRequest';
+import type { IRegisterRequest } from '@src/modules/Users/interface/dto/IRegisterRequest';
+import type { IAuthUseCases } from '@src/modules/Users/application/ports/IAuthUseCases';
+
+export class AuthController extends BaseController implements IController {
+  private readonly authUseCases: IAuthUseCases;
+
+  // eslint-disable-next-line no-useless-constructor
+  constructor(factory: IControllerFactory) {
+    super(factory);
+    if (!factory.authUseCases) {
+      throw new Error('AuthUseCases is not implemented');
+    }
+    this.authUseCases = factory.authUseCases;
+  }
+
+  public async login(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IAuthorizationHeader>> {
+    validateRequestAgainstOAS(
+      this.openApiSpecification,
+      event.schemaOAS,
+      event
+    );
+    const loginRequest = event.input as ILoginRequest;
+    const { result, error } = await this.authUseCases.login({
+      ...loginRequest,
+      schemaType: loginRequest.schemaType ?? EAuthSchemaType.Bearer
+    });
+
+    return { result, error };
+  }
+
+  public async register(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<Record<string, any>>> {
+    validateRequestAgainstOAS(
+      this.openApiSpecification,
+      event.schemaOAS,
+      event
+    );
+    const registerRequest = event.input as IRegisterRequest;
+
+    const { result, error } = await this.authUseCases.register(registerRequest);
+
+    return { result, error };
+  }
+
+  @Authorize()
+  public async updatePassword(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<boolean>> {
+    validateRequestAgainstOAS(
+      this.openApiSpecification,
+      event.schemaOAS,
+      event
+    );
+    const updatePasswordRequest = event.input as IUpdatePasswordRequest;
+    return this.authUseCases.updatePassword(event.authorization, updatePasswordRequest);
+  }
+
+  @Authorize()
+  public async logout(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<boolean>> {
+    validateRequestAgainstOAS(
+      this.openApiSpecification,
+      event.schemaOAS,
+      event
+    );
+    const logoutRequest = event.input as ILogoutRequest;
+    return this.authUseCases.logout(event.authorization, logoutRequest);
+  }
+
+  public static compile(factory: IControllerFactory) {
+    return new AuthController(factory);
+  }
+}

package/templates/backend/src/modules/Users/adapters/in/http/controllers/OrganizationController.ts

@@ -0,0 +1,350 @@
+import type { IController, IControllerFactory } from '@src/interface/HTTP/ports';
+import { BaseController } from '@src/interface/HTTP/ports/BaseController';
+import { Security } from '@src/infra/security';
+import { _INFRA_NOT_IMPLEMENTED_ } from '@src/config/constants';
+import { ForbiddenError } from '@src/infra/exceptions';
+import { validateRequestAgainstOAS } from '@src/interface/HTTP/validators';
+import { Authorize } from '@src/shared/decorators/guard/Authorize';
+import { BaseDomainEvent } from '@src/modules/port/BaseDomainEvent';
+import type {
+  IServiceResponse
+} from '@src/modules/port';
+import { setListQuery, setMetricsQuery } from '@src/modules/port';
+import type { IOrganization } from '@src/modules/Users/domain/Entity/IOrganization';
+import type { IOrganizationUseCases } from '@src/modules/Users/application/ports/IOrganizationUseCases';
+import type { RequestCreateOrganization } from '@src/modules/Users/interface/dto/RequestCreateOrganization';
+import type { RequestUpdateOrganization } from '@src/modules/Users/interface/dto/RequestUpdateOrganization';
+import type { RequestCreateAddress } from '@src/modules/Users/interface/dto/RequestCreateAddress';
+import type { RequestUpdateAddress } from '@src/modules/Users/interface/dto/RequestUpdateAddress';
+import type { RequestCreatePhone } from '@src/modules/Users/interface/dto/RequestCreatePhone';
+import type { RequestUpdatePhone } from '@src/modules/Users/interface/dto/RequestUpdatePhone';
+import type { RequestCreateEmail } from '@src/modules/Users/interface/dto/RequestCreateEmail';
+import type { RequestUpdateEmail } from '@src/modules/Users/interface/dto/RequestUpdateEmail';
+import type {
+  ITenantAuthorizationDecision
+} from '@src/modules/Users/domain/security/TenantAuthorizationPolicy';
+import {
+  decideOrganizationAccess,
+  resolveOrganizationCollectionScope
+} from '@src/modules/Users/domain/security/TenantAuthorizationPolicy';
+
+export class OrganizationController extends BaseController implements IController {
+  private readonly organizationUseCases: IOrganizationUseCases;
+
+  constructor(factory: IControllerFactory) {
+    super(factory);
+    if (!factory.organizationUseCases) {
+      const error = new Error('OrganizationUseCases is not implemented');
+      error.name = _INFRA_NOT_IMPLEMENTED_;
+      throw error;
+    }
+    this.organizationUseCases = factory.organizationUseCases;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  private getAuthenticatedUser(event: BaseDomainEvent): Record<string, any> {
+    return ((event as any).authenticatedUser || {}) as Record<string, any>;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  private throwIfTenantAccessDenied(decision: ITenantAuthorizationDecision): void {
+    if (!decision.allowed) {
+      throw new ForbiddenError(decision.reason);
+    }
+  }
+
+  private enforceOrganizationScope(event: BaseDomainEvent, organizationId: string): void {
+    const authenticatedUser = this.getAuthenticatedUser(event);
+    this.throwIfTenantAccessDenied(decideOrganizationAccess(
+      authenticatedUser,
+      organizationId
+    ));
+  }
+
+  @Authorize()
+  public async create(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const requestCreateOrganization = event.input as RequestCreateOrganization;
+    const { result, error } = await this.organizationUseCases.create(requestCreateOrganization);
+    return { result, error };
+  }
+
+  @Authorize()
+  public async update(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const requestUpdateOrganization = event.input as RequestUpdateOrganization;
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const { result, error } = await this.organizationUseCases.update(
+      organizationId,
+      requestUpdateOrganization
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async delete(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<boolean>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const { result, error } = await this.organizationUseCases.delete(organizationId);
+    return { result, error };
+  }
+
+  @Authorize()
+  public async getOneById(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const { result, error } = await this.organizationUseCases.getOneById(organizationId);
+    return { result, error };
+  }
+
+  @Authorize()
+  public async getAll(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization[]>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    // JUM-777: page/size/filter/sort/q validated against x-list-capabilities.
+    const { filters, paging } = setListQuery(event);
+    const authenticatedUser = this.getAuthenticatedUser(event);
+    const tenantScope = resolveOrganizationCollectionScope(authenticatedUser);
+    this.throwIfTenantAccessDenied(tenantScope.decision);
+    return this.organizationUseCases.getAll(
+      { ...filters, ...tenantScope.filters },
+      paging
+    );
+  }
+
+  @Authorize()
+  public async getOrganizationsMetrics(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<unknown>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const { query, filters, capabilities } = setMetricsQuery(event);
+    const authenticatedUser = this.getAuthenticatedUser(event);
+    const tenantScope = resolveOrganizationCollectionScope(authenticatedUser);
+    this.throwIfTenantAccessDenied(tenantScope.decision);
+    return this.organizationUseCases.metrics(
+      { ...filters, ...tenantScope.filters },
+      query,
+      capabilities
+    );
+  }
+
+  @Authorize()
+  public async createAddress(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const requestCreateAddress = event.input as RequestCreateAddress;
+    const { result, error } = await this.organizationUseCases.createAddress(
+      organizationId,
+      requestCreateAddress
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async updateAddress(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const addressId = Security.xss(event.params.addressId);
+    const requestUpdateAddress = event.input as RequestUpdateAddress;
+    const { result, error } = await this.organizationUseCases.updateAddress(
+      organizationId,
+      addressId,
+      requestUpdateAddress
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async deleteAddress(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const addressId = Security.xss(event.params.addressId);
+    const { result, error } = await this.organizationUseCases.deleteAddress(
+      organizationId,
+      addressId
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async createPhone(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const requestCreatePhone = event.input as RequestCreatePhone;
+    const { result, error } = await this.organizationUseCases.createPhone(
+      organizationId,
+      requestCreatePhone
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async updatePhone(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const phoneId = Security.xss(event.params.phoneId);
+    const requestUpdatePhone = event.input as RequestUpdatePhone;
+    const { result, error } = await this.organizationUseCases.updatePhone(
+      organizationId,
+      phoneId,
+      requestUpdatePhone
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async deletePhone(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const phoneId = Security.xss(event.params.phoneId);
+    const { result, error } = await this.organizationUseCases.deletePhone(
+      organizationId,
+      phoneId
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async createEmail(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const requestCreateEmail = event.input as RequestCreateEmail;
+    const { result, error } = await this.organizationUseCases.createEmail(
+      organizationId,
+      requestCreateEmail
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async updateEmail(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const emailId = Security.xss(event.params.emailId);
+    const requestUpdateEmail = event.input as RequestUpdateEmail;
+    const { result, error } = await this.organizationUseCases.updateEmail(
+      organizationId,
+      emailId,
+      requestUpdateEmail
+    );
+    return { result, error };
+  }
+
+  @Authorize()
+  public async deleteEmail(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    validateRequestAgainstOAS(this.openApiSpecification, event.schemaOAS, event);
+    const organizationId = Security.xss(event.params.id);
+    this.enforceOrganizationScope(event, organizationId);
+    const emailId = Security.xss(event.params.emailId);
+    const { result, error } = await this.organizationUseCases.deleteEmail(
+      organizationId,
+      emailId
+    );
+    return { result, error };
+  }
+
+  // Backward-compatible aliases for existing operationIds/handlers.
+  public createOrganization(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.create(event);
+  }
+
+  public updateOrganization(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.update(event);
+  }
+
+  public deleteOrganization(event: BaseDomainEvent): Promise<IServiceResponse<boolean>> {
+    return this.delete(event);
+  }
+
+  public getOrganizationById(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.getOneById(event);
+  }
+
+  public getAllOrganizations(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization[]>> {
+    return this.getAll(event);
+  }
+
+  public createOrganizationAddress(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.createAddress(event);
+  }
+
+  public updateOrganizationAddress(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.updateAddress(event);
+  }
+
+  public deleteOrganizationAddress(
+    event: BaseDomainEvent
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.deleteAddress(event);
+  }
+
+  public createOrganizationPhone(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.createPhone(event);
+  }
+
+  public updateOrganizationPhone(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.updatePhone(event);
+  }
+
+  public deleteOrganizationPhone(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.deletePhone(event);
+  }
+
+  public createOrganizationEmail(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.createEmail(event);
+  }
+
+  public updateOrganizationEmail(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.updateEmail(event);
+  }
+
+  public deleteOrganizationEmail(event: BaseDomainEvent): Promise<IServiceResponse<IOrganization>> {
+    return this.deleteEmail(event);
+  }
+
+  public static compile(factory: IControllerFactory) {
+    return new OrganizationController(factory);
+  }
+}