@quan-erp/shared-backend-core 1.0.1

package/dist/types/6610c73e/87f29211/b10ca3c4/f6334307.d.ts

@@ -0,0 +1,27 @@
+import { RoleDto } from "../../4b168d88/d96befb1.js";
+import { UserDto } from "../../04f8996d/57b46faf.js";
+import { AISDKAPIType, AISDKAPITypeValue } from "../a9d0df18/16022771.js";
+export declare const MASKED_API_KEY = "********";
+export type CreateAIModelDto = ({
+    sdkType: typeof AISDKAPIType.OpenAI;
+    baseUrl: string;
+    model: string;
+} | {
+    sdkType: typeof AISDKAPIType.Gemini;
+    model: string;
+}) & {
+    name: string;
+    apiKey: string;
+    userId: number;
+    baseUrl?: string;
+    allowedRoleId: number[];
+};
+export type AIModelDto = {
+    name: string;
+    model: string;
+    baseUrl?: string | null | undefined;
+    isActive: boolean;
+    sdkType: AISDKAPITypeValue;
+    createdBy: UserDto;
+    allowedRoles: RoleDto[];
+};

package/dist/types/6610c73e/87f29211/fc973325/1abe9fb9.d.ts

@@ -0,0 +1,26 @@
+import { DataSource } from "typeorm";
+import { Loggable } from "../../../0d45f5fd/4dd6b41d.js";
+import { AIAssistantTools } from "../a9d0df18/16022771.js";
+import { OpenAI as OpenAIClient } from 'openai';
+import { AIToolUtilitiesFunctions } from "./9c8f6046.js";
+import { AIToolsEntity } from "../../../871f3f39/9341b4c5.js";
+export declare class AIToolsService {
+    private tools;
+    source: DataSource;
+    logger: Loggable;
+    utilitiesFun: AIToolUtilitiesFunctions;
+    private partnerService;
+    private branchService;
+    constructor();
+    get repo(): import("typeorm").Repository<AIToolsEntity>;
+    registerTool(tool: AIAssistantTools): Promise<void>;
+    removeTool(pluginName: string, fnName: string): Promise<void>;
+    getTools(): AIAssistantTools[];
+    getAllToolsDetail(): OpenAIClient.Chat.Completions.ChatCompletionFunctionTool[];
+    getToolsDetailsByFunctionName(fnName: {
+        fnName: string;
+        pluginName: string;
+    }[]): OpenAIClient.Chat.Completions.ChatCompletionFunctionTool[];
+    callToolByFunctionName(toolName: string, args: any): Promise<any>;
+    onInit(): Promise<void>;
+}

package/dist/types/6610c73e/87f29211/fc973325/60e62909.d.ts

@@ -0,0 +1,9 @@
+import { ResponseDto } from "../../../9477dda6/a68fa9aa.js";
+import { AIToolsService } from "./1abe9fb9.js";
+export declare class AIToolsController {
+    toolService: AIToolsService;
+    getToolList(search: string): ResponseDto<{
+        pluginName: string;
+        toolDetail: import("openai/resources").ChatCompletionFunctionTool;
+    }[]>;
+}

package/dist/types/6610c73e/87f29211/fc973325/8e609bb7.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/6610c73e/87f29211/fc973325/9c8f6046.d.ts

@@ -0,0 +1,23 @@
+import { DataSource, EntityTarget } from "typeorm";
+import { Loggable } from "../../../0d45f5fd/4dd6b41d.js";
+export declare const ignoredTables: string[];
+export declare class AIToolUtilitiesFunctions {
+    private aiModelService;
+    source: DataSource;
+    logger: Loggable;
+    humanLanguageToSQL(prompt: string, schema: Record<string, any>, ingoreTables?: string[]): Promise<string>;
+    extractInfoFromEntities(entities: EntityTarget<any>[], ignoreTables?: string[]): {
+        schema: Record<string, any>;
+        relationships: {
+            from: string;
+            to: string;
+        }[];
+    };
+    extractRelationsFromEntities(entities: EntityTarget<any>[], ignoreTables?: string[]): {
+        from: string;
+        to: string;
+    }[];
+    getAllEntitiesFromPlugin(pluginName?: string): EntityTarget<any>[];
+    queryDatabase(sql: string): Promise<any>;
+    private getEntityPrototype;
+}

package/dist/types/6610c73e/8a6cead4/40c4faf7.d.ts

@@ -0,0 +1,8 @@
+import { DataSource } from "typeorm";
+import { MigrationEntity } from "../../871f3f39/6a0d07bb.js";
+export declare class MigrationService {
+    source: DataSource;
+    get repo(): import("typeorm").Repository<MigrationEntity>;
+    get(pluginName: string): Promise<MigrationEntity[]>;
+    getLastMigration(pluginName: string): Promise<MigrationEntity | null>;
+}

package/dist/types/6610c73e/b77349bf/2349cc94.d.ts

@@ -0,0 +1,13 @@
+export type EnvDto = {
+    pluginName: string;
+    key: string;
+    value: string;
+    isSecret: boolean;
+    isPublic: boolean;
+};
+export type SeedEnvDto = {
+    pluginName: string;
+    key: string;
+    isSecret: boolean;
+    isPublic: boolean;
+};

package/dist/types/6610c73e/b77349bf/6d87f127.d.ts

@@ -0,0 +1,12 @@
+import { DataSource } from "typeorm";
+import { EnvDto, SeedEnvDto } from "./2349cc94.js";
+import { EnvEntity } from "../../871f3f39/4ec64ebc.js";
+export declare class EnvService {
+    source: DataSource;
+    get repo(): import("typeorm").Repository<EnvEntity>;
+    create(env: EnvDto[]): Promise<void>;
+    get(pluginName: string, key: string): Promise<EnvDto | null>;
+    getAll(): Promise<EnvDto[]>;
+    seed(envs: SeedEnvDto[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/6610c73e/b77349bf/af3f15da.d.ts

@@ -0,0 +1,29 @@
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { NodeStatusService } from "../09355034/5f5422ae.js";
+import { EnvService } from "./6d87f127.js";
+export declare class EnvController {
+    nodeStatus: NodeStatusService;
+    envService: EnvService;
+    get app(): import("../../core/app-helper.js").CoreApp;
+    getEnv(): ResponseDto<Record<string, Record<string, {
+        value: string;
+        isPublic: boolean;
+        isSecret: boolean;
+    }>>>;
+    getPublicEnv(): ResponseDto<Record<string, Record<string, {
+        value: string;
+        isPublic: boolean;
+        isSecret: boolean;
+    }>>>;
+    getEnvFromDb(): Promise<ResponseDto<import("./env.dto.js").EnvDto[]>>;
+    setEnv(body: RequestDto<{
+        plugin: string;
+        key: string;
+        val: string;
+    }>): Promise<void>;
+    setEnvs(body: RequestDto<Record<string, Record<string, {
+        value: string;
+        isPublic: boolean;
+        isSecret: boolean;
+    }>>>): Promise<ResponseDto<null>>;
+}

package/dist/types/6610c73e/b96961ed.d.ts

@@ -0,0 +1,31 @@
+export * from "./f38c764c/4d91b5ee.js";
+export * from "./f38c764c/50b90d0c.js";
+export * from "./04f8996d/45843092.js";
+export * from "./04f8996d/57b46faf.js";
+export * from "./87f29211/0f8de574/da48b377.js";
+export * from "./87f29211/fc973325/9c8f6046.js";
+export * from "./87f29211/87f29211/8e609bb7.js";
+export * from "./87f29211/87f29211/05219fd0.js";
+export * from "./87f29211/00282ba1/cc85368e.js";
+export * from "./87f29211/b10ca3c4/805c4d09.js";
+export * from "./87f29211/b10ca3c4/f6334307.js";
+export * from "./87f29211/fc973325/1abe9fb9.js";
+export * from "./87f29211/fc973325/8e609bb7.js";
+export * from "./87f29211/a9d0df18/8e25f6cf.js";
+export * from "./87f29211/a9d0df18/4ca22be8.js";
+export * from "./87f29211/a9d0df18/326e8c85.js";
+export * from "./87f29211/a9d0df18/16022771.js";
+export * from "./87f29211/6fd89734/7c0d7562.js";
+export * from "./fdeb3389/16152e20.js";
+export * from "./6e1815de/1ec1270e.js";
+export * from "./6e1815de/cb4e0d9d.js";
+export * from "./5e689e2b/08490b99.js";
+export * from "./5e689e2b/f6474de5.js";
+export * from "./8a6cead4/40c4faf7.js";
+export * from "./4b168d88/413ef4e3.js";
+export * from "./4b168d88/d96befb1.js";
+export * from "./da7f739f/e016487a.js";
+export * from "./c374eea5/4f55037c.js";
+export * from "./c374eea5/d76ffdee.js";
+export * from "./2a1073a6/13feb6a7.js";
+export * from "./2a1073a6/48a99f86.js";

package/dist/types/6610c73e/bbc5e661/1f1e37e4.d.ts

@@ -0,0 +1,12 @@
+import { GracefulJobManager } from "../../0d45f5fd/496c2854.js";
+import { ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { SystemDto } from "./803a3b35.js";
+import { SystemService } from "./edfe1989.js";
+import { NodeStatusService } from "../09355034/5f5422ae.js";
+export declare class SystemController {
+    graceful: GracefulJobManager;
+    service: SystemService;
+    nodeStatusService: NodeStatusService;
+    get(): Promise<ResponseDto<SystemDto>>;
+    requestRestart(): ResponseDto<null>;
+}

package/dist/types/6610c73e/bbc5e661/803a3b35.d.ts

@@ -0,0 +1,6 @@
+export type SystemDto = {
+    isSafeShutdown: boolean;
+    avgComputeUsage: number;
+    memoryUsage: number;
+    appDiskUsage: number;
+};

package/dist/types/6610c73e/bbc5e661/edfe1989.d.ts

@@ -0,0 +1,14 @@
+import { GracefulJobManager } from "../../0d45f5fd/496c2854.js";
+import { ICache } from "../../0d45f5fd/9a2c73cf.js";
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+import { IAppInstance } from "@quan-erp/shared-types";
+export declare class SystemService {
+    gracefulJob: GracefulJobManager;
+    cache: ICache;
+    logger: Loggable;
+    appInstance: IAppInstance;
+    getCpuUsage(): number;
+    getMemoryUsage(): number;
+    getAppDiskUsage(): Promise<number>;
+    requestRestart(): void;
+}

package/dist/types/6610c73e/bd5c70f7/cf852c15.d.ts

@@ -0,0 +1,20 @@
+import { DataSource } from "typeorm";
+import { HttpMethod } from "../../0d45f5fd/1c59aca9.js";
+import { RouteType } from "../../2cc49785/46f89c68.js";
+type PageRoute = {
+    type: RouteType.PAGE;
+    route: string;
+    description: string;
+};
+type APIRoute = {
+    type: RouteType.API;
+    route: string;
+    method: HttpMethod;
+    description: string;
+};
+export declare class PluginRouteService {
+    source: DataSource;
+    addRoutes(id: number, routes: (PageRoute | APIRoute)[]): Promise<void>;
+    addRoute(id: number, route: PageRoute | APIRoute): Promise<void>;
+}
+export {};

package/dist/types/6610c73e/c374eea5/4f55037c.d.ts

@@ -0,0 +1,36 @@
+import { CronJobCallback, CreateCronJobDTO } from "./d76ffdee.js";
+import { CronJobEntity } from "../../871f3f39/708e3b90.js";
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+export declare class CronJobService {
+    private dataSource;
+    private queue;
+    private worker;
+    private listener;
+    logger: Loggable;
+    private bean;
+    private allModuleLoaded;
+    private onUninstalled;
+    private get queueName();
+    private get repo();
+    private get defaultRedisConnectionOptions();
+    register(dto: CreateCronJobDTO): Promise<void>;
+    stop(pluginName: string, jobName: string): Promise<void>;
+    stopAllByPluginName(pluginName: string): Promise<void>;
+    removeAllByPluginName(pluginName: string): Promise<void>;
+    remove(pluginName: string, jobName: string): Promise<void>;
+    getActiveCronJobs(skip: number, limit: number): Promise<CronJobEntity[]>;
+    updateCronJobStatus(pluginName: string, jobName: string, status: 'active' | 'inactive'): Promise<void>;
+    getByPluginNameWithJobName(pluginName: string, jobName: string): Promise<CronJobEntity | null>;
+    getByPluginName(props: {
+        pluginName: string;
+        skip: number;
+        limit: number;
+        status?: 'active' | 'inactive';
+    }): Promise<CronJobEntity[]>;
+    private reloadQueue;
+    private initializeWorker;
+    private getListener;
+    addEventListener(pluginName: string, jobName: string, callback: CronJobCallback): string;
+    removeEventListener(pluginName: string, jobName: string): void;
+    removeEvenListenerById(listenerId: string): void;
+}

package/dist/types/6610c73e/c374eea5/8a8646a7.d.ts

@@ -0,0 +1,9 @@
+import { CronJobService } from "./4f55037c.js";
+import { CreateCronJobDTO } from "./d76ffdee.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+export declare class CronJobController {
+    service: CronJobService;
+    register(body: RequestDto<CreateCronJobDTO>): Promise<ResponseDto<null>>;
+    getCronJobs(skip: number, limit: number): Promise<void>;
+    deleteCronJob(id: number): Promise<void>;
+}

package/dist/types/6610c73e/c374eea5/d76ffdee.d.ts

@@ -0,0 +1,38 @@
+import { Job } from "bullmq";
+export type CronJobCallback = (job: Job<any, any, string>) => void;
+export type CreateCronJobDTO = {
+    cronExpression: string;
+    status?: 'active' | 'inactive';
+    pluginName: string;
+    jobName: string;
+    data?: Record<string, any>;
+    startDate?: Date;
+    repeat?: RepeatOption;
+    retry?: CronRetryOption;
+    callback?: CronJobCallback;
+};
+export type RepeatOption = {
+    limit: number;
+};
+export type CronRetryOption = {
+    attempt: number;
+    delay: number;
+    type: 'fixed' | 'exponential';
+};
+export type CronJobData = {
+    pluginName: string;
+} & Record<any, any>;
+export type CronJobDTO = {
+    id: number;
+    cronExpression: string;
+    status: 'active' | 'inactive';
+    jobName: string;
+    headers: Record<string, any>;
+    apiUrl: string;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch';
+    body: Record<string, any>;
+    param: Record<string, any>;
+    query: Record<string, any>;
+    createdAt?: Date;
+    updatedAt?: Date;
+};

package/dist/types/6610c73e/da7f739f/186461ad.d.ts

@@ -0,0 +1,20 @@
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { Workflow } from "../../0d45f5fd/da7f739f/f7427a8d.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { WorkflowService } from "./e016487a.js";
+import { Request, Response } from "express";
+export declare class WorkflowController {
+    service: WorkflowService;
+    availableNodes(): ResponseDto<Record<string, Record<string, import("../../index.js").WorkflowNodeDefination>>>;
+    activate(id: number, body: RequestDto<{
+        activate: boolean;
+    }>): Promise<ResponseDto<null>>;
+    executeHistory(skip: number, limit: number): Promise<ResponseDto<import("../../index.js").WorkflowExecutionHistoryEntity[]>>;
+    execute(id: number, body: RequestDto<any>): Promise<ResponseDto<null>>;
+    trigger(workflowId: number, req: Request, res: Response): Promise<ResponseDto<null> | undefined>;
+    create(body: RequestDto<Workflow>, user: RequestedUser): Promise<ResponseDto<void>>;
+    get(skip: number, limit: number): Promise<ResponseDto<import("../../index.js").WorkflowEntity[]>>;
+    update(id: number, body: RequestDto<Workflow>): Promise<ResponseDto<null>>;
+    getById(id: number): Promise<ResponseDto<import("../../index.js").WorkflowEntity | null>>;
+    delete(id: number): Promise<ResponseDto<null>>;
+}

package/dist/types/6610c73e/da7f739f/e016487a.d.ts

@@ -0,0 +1,45 @@
+import { DataSource } from "typeorm";
+import { Workflow } from "../../0d45f5fd/da7f739f/f7427a8d.js";
+import { WorkflowEntity, WorkflowExecutionHistoryEntity } from "../../871f3f39/e4e56e24.js";
+import { Request, Response } from 'express';
+import { CronJobService } from "../c374eea5/4f55037c.js";
+import { ExecutionContext } from "../../0d45f5fd/da7f739f/597ef69e.js";
+export declare class WorkflowService {
+    #private;
+    datasource: DataSource;
+    cronJobService: CronJobService;
+    private get repo();
+    private get workflowChangesRepo();
+    private get executionHistoryRepo();
+    onInit(): Promise<void>;
+    create(workflow: Workflow, userId: number): Promise<void>;
+    update(id: number, workflow: Workflow): Promise<void>;
+    findById(id: number): Promise<WorkflowEntity | null>;
+    findAll(skip: number, limit: number): Promise<WorkflowEntity[]>;
+    findByInitNodeType(initNodeType: string, option?: {
+        active?: boolean;
+    }): Promise<WorkflowEntity[]>;
+    deleteById(id: number): Promise<import("typeorm").UpdateResult>;
+    activate(id: number, flag: boolean): Promise<import("typeorm").UpdateResult | undefined>;
+    getAvailableNodes(): Record<string, Record<string, import("../../index.js").IWorkflowNode<any, any, any>>>;
+    getAvailableNodesArray(): import("../../index.js").IWorkflowNode<any, any, any>[];
+    execute(props: {
+        workflowId: number;
+        initNodeId?: string;
+        args?: any;
+        privateVariables?: Map<string, any>;
+    }): Promise<ExecutionContext>;
+    executeWorkflow({ workflow, initNodeId, args, privateVariables }: {
+        workflow: Workflow | WorkflowEntity;
+        initNodeId?: string;
+        args?: any;
+        privateVariables?: Map<string, any>;
+    }): Promise<ExecutionContext>;
+    trigger(workflowId: number, req: Request, res: Response): Promise<{
+        isHttpResponseHandled: boolean;
+    }>;
+    getExecutionHistory(skip: number, limit: number): Promise<WorkflowExecutionHistoryEntity[]>;
+    private getCronJobWorkflows;
+    private buildCronJobName;
+    private registerCronJob;
+}

package/dist/types/6610c73e/f38c764c/4d91b5ee.d.ts

@@ -0,0 +1,79 @@
+import { DataSource } from "typeorm";
+import { BranchEntity } from "../../871f3f39/a225cc21.js";
+import { CreateBranchDto } from "./50b90d0c.js";
+import { CreateServiceProps, OptionalCreatedByUser } from "../../abe2c417/8f79089f.js";
+import { DeveloperConfigService } from "../../2ad56231/01dcea55/0a5f3cca.js";
+import { SportlightSearchDto } from "../../9477dda6/a16c3886.js";
+import { PermissionService } from "../fdeb3389/16152e20.js";
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { ChangeLogService } from "../../2ad56231/7f9ba364/e4ec6555.js";
+interface IBranchService {
+}
+/**
+ * Service responsible for managing organizational branches.
+ *
+ * Handles the creation, retrieval, updates, and global search of physical
+ * locations. It enforces business rules such as branch limits (defined in
+ * DeveloperConfig) and maintains a historical audit trail via ChangeLogService.
+ */
+export declare class BranchService implements IBranchService {
+    source: DataSource;
+    changeLogService: ChangeLogService;
+    developerConfigService: DeveloperConfigService;
+    permissionService: PermissionService;
+    /**
+     * Calculates the total number of organizational branches defined in the system.
+     * @param props - Optional execution context (manager).
+     */
+    private countTotalBranch;
+    /**
+     * Atomically creates or updates an organizational branch, enforcing limits.
+     *
+     * @param params - The branch entity metadata to persist.
+     * @throws Error if the MAX_ORGANIZATION_BRANCH defined in developer config is exceeded.
+     */
+    create(params: CreateServiceProps<CreateBranchDto & OptionalCreatedByUser>): Promise<void>;
+    /**
+     * Finds a specific branch by its unique identifier.
+     * @param id - The numeric branch ID.
+     */
+    getById(id: number): Promise<BranchEntity | null>;
+    /**
+     * Retrieves a paginated list of all active organizational branches.
+     *
+     * @param options - Includes search query, pagination skip/limit.
+     * @returns A collection of branches matching the criteria.
+     */
+    get({ skip, limit, search }: {
+        skip?: number;
+        limit?: number;
+        search?: string;
+    }): Promise<BranchEntity[]>;
+    /**
+     * Updates an existing branch's metadata and records the change in the audit log.
+     *
+     * @param id - The ID of the branch to update.
+     * @param data - The new branch metadata.
+     * @param updatedByUserId - The ID of the user performing the update.
+     * @throws Error if the branch is not found.
+     */
+    update(id: number, data: any, updatedByUserId?: number): Promise<void>;
+    /**
+     * Integrates branches into the global Spotlight search feature.
+     *
+     * Implements strict RBAC checks to ensure the requesting user has
+     * visibility into organizational data before executing linguistic queries.
+     *
+     * @param dto - Global search query and strategy context.
+     * @param user - Information about the requesting user.
+     * @returns A collection of branches matching the search query.
+     */
+    sportlightSearch(dto: SportlightSearchDto, user: RequestedUser): Promise<BranchEntity[]>;
+    /**
+     * Marks a specific branch as the default branch.
+     * Ensures all other branches are set to not default first.
+     * All operations are executed within a transaction.
+     */
+    markDefault(id: number, userId: number): Promise<void>;
+}
+export {};

package/dist/types/6610c73e/f38c764c/50b90d0c.d.ts

@@ -0,0 +1,33 @@
+import { TagDto } from "../2a1073a6/48a99f86.js";
+export declare class BranchDto {
+    id: number;
+    name: string;
+    address?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    phone?: string;
+    email?: string;
+    tags?: TagDto[];
+    isActive: boolean;
+    isDefault: boolean;
+    createDate: Date;
+    updateDate: Date;
+    deleteDate?: Date;
+    version: number;
+}
+export declare class CreateBranchDto {
+    id: number;
+    name: string;
+    address?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    phone?: string;
+    email?: string;
+    tags?: number[];
+    isActive: boolean;
+    isDefault: boolean;
+}

package/dist/types/6610c73e/f38c764c/e1fae94b.d.ts

@@ -0,0 +1,14 @@
+import { RequestedUser } from "../../index.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { SportlightSearchDto } from "../../9477dda6/a16c3886.js";
+import { BranchEntity } from "../../871f3f39/a225cc21.js";
+import { BranchDto } from "./50b90d0c.js";
+import { BranchService } from "./4d91b5ee.js";
+export declare class BranchConroller {
+    service: BranchService;
+    get(skip: number | undefined, limit: number | undefined, search: string): Promise<ResponseDto<BranchEntity[]>>;
+    new(branch: RequestDto<BranchEntity>, user: RequestedUser): Promise<ResponseDto<null>>;
+    update(body: RequestDto<BranchDto>, id: number, user: RequestedUser): Promise<ResponseDto<null>>;
+    markDefault(id: number, user: RequestedUser): Promise<ResponseDto<null>>;
+    search(body: RequestDto<SportlightSearchDto>, user: RequestedUser): Promise<ResponseDto<BranchEntity[]>>;
+}

package/dist/types/6610c73e/fdeb3389/16152e20.d.ts

@@ -0,0 +1,103 @@
+import { DataSource } from "typeorm";
+import { PermissionEntity } from "../../871f3f39/2bfe94e3.js";
+import { PermissionPayload } from "./81528d33.js";
+import { HttpMethod } from "../../0d45f5fd/1c59aca9.js";
+interface IPermissionService {
+}
+/**
+ * Service responsible for managing API-level authorization and permissions.
+ *
+ * The `PermissionService` acts as the security enforcement engine for
+ * URL-based access control. It handles:
+ * 1. **Authorization Mapping**: Connecting specific HTTP methods and URL paths
+ *    to user roles.
+ * 2. **High-Performance Checks**: Utilizing a specialized caching layer
+ *    (`SINGLE_PERMISSION_CACHE`) to avoid database round-trips during
+ *    middleware authorization checks.
+ * 3. **Bulk Management**: Atomically applying or updating permission sets
+ *    for roles through transactional operations.
+ */
+export declare class PermissionService implements IPermissionService {
+    source: DataSource;
+    private get permissionRepository();
+    private get roleRepository();
+    /**
+     * Retrieves all Permission entities, eagerly loading the associated Role.
+     * @returns A list of all URL-to-Role permission mappings.
+     */
+    findAll(): Promise<PermissionEntity[]>;
+    /**
+     * Finds a specific Permission entity by its primary key.
+     * @param id - The numeric ID of the permission.
+     */
+    findById(id: number): Promise<PermissionEntity | null>;
+    /**
+     * Retrieves all permissions assigned to a specific role.
+     * @param id - The unique ID of the role.
+     */
+    findByRoleId(id: number): Promise<PermissionEntity[]>;
+    /**
+     * Retrieves permission records matching specific API endpoints and a role.
+     *
+     * This method is backed by the `SINGLE_PERMISSION_CACHE` to ensure that
+     * repeated authorization checks do not impact performance.
+     *
+     * @param props - An array of objects containing roleId, url, and method to check.
+     */
+    findByAPIWithRoleId(props: {
+        roleId: number;
+        url: string;
+        method: HttpMethod;
+    }[]): Promise<PermissionEntity[]>;
+    /**
+     * Validates whether a specific role has permissions for one or more API endpoints.
+     *
+     * @param props - The set of role, URL, and method combinations to validate.
+     * @returns True if ALL requested permissions are explicitly granted in the system.
+     */
+    hasRequiredPermissions(props: {
+        roleId: number;
+        url: string;
+        method: HttpMethod;
+    }[]): Promise<boolean>;
+    /**
+     * Creates a new Permission mapping and associates it with a Role.
+     *
+     * @param data - The permission payload including URL, method, and target roleId.
+     * @returns The newly created permission entity.
+     * @throws Error if the target role does not exist.
+     */
+    create(data: PermissionPayload): Promise<PermissionEntity>;
+    /**
+     * Bulk inserts multiple permission mappings.
+     *
+     * Uses an upsert strategy with conflicts handled on URL, Role, and Method paths.
+     *
+     * @param data - Array of permission payloads to create.
+     */
+    createAll(data: PermissionPayload[]): Promise<void>;
+    /**
+     * Replaces the entire permission set for a specific role atomically.
+     *
+     * Deletes all existing permissions for the role and inserts the new set
+     * within a single database transaction.
+     *
+     * @param roleId - The target role ID.
+     * @param data - The new collection of permissions to apply.
+     */
+    applyAll(roleId: number, type: 'allow' | 'deny' | 'replace', data: PermissionPayload[]): Promise<void>;
+    /**
+     * Updates an existing permission record metadata.
+     *
+     * @param id - The numeric ID of the permission record.
+     * @param data - Partial update payload.
+     * @returns The updated permission entity.
+     */
+    update(id: number, type: 'allow' | 'deny' | 'replace', data: Partial<PermissionPayload>): Promise<PermissionEntity>;
+    /**
+     * Soft-deletes a permission entity from the system.
+     * @param id - The ID of the permission mapping to remove.
+     */
+    delete(id: number): Promise<void>;
+}
+export {};

package/dist/types/6610c73e/fdeb3389/1f95de59.d.ts

@@ -0,0 +1,19 @@
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { PermissionPayload } from "./81528d33.js";
+export declare class PermissionController {
+    private permissionService;
+    findAll(): Promise<ResponseDto<import("../../index.js").PermissionEntity[]>>;
+    getByRole(id: number): Promise<ResponseDto<import("../../index.js").PermissionEntity[]>>;
+    applyRole(id: number, type: "allow" | "deny" | "replace" | undefined, body: RequestDto<PermissionPayload[]>): Promise<ResponseDto<null>>;
+    findById(id: number): Promise<ResponseDto<import("../../index.js").PermissionEntity> | {
+        success: boolean;
+        message: string;
+    }>;
+    create(body: RequestDto<PermissionPayload>): Promise<ResponseDto<any> | {
+        success: boolean;
+        data: import("../../index.js").PermissionEntity;
+        message: string;
+    }>;
+    update(id: number, type: "allow" | "deny" | "replace" | undefined, body: ResponseDto<Partial<PermissionPayload>>): Promise<ResponseDto<any>>;
+    delete(id: number): Promise<ResponseDto<any>>;
+}