nucleus-core-ts 0.8.0

package/dist/src/Services/Monitoring/types.d.ts

@@ -0,0 +1,163 @@
+export interface MonitoringConfig {
+    enabled?: boolean;
+    system?: {
+        enabled?: boolean;
+        collectInterval?: string;
+        metrics?: {
+            cpu?: boolean;
+            memory?: boolean;
+            disk?: boolean;
+            network?: boolean;
+            process?: boolean;
+        };
+    };
+    application?: {
+        enabled?: boolean;
+        metrics?: {
+            requests?: boolean;
+            responseTime?: boolean;
+            errors?: boolean;
+            rateLimits?: boolean;
+        };
+    };
+    database?: {
+        enabled?: boolean;
+        metrics?: {
+            connections?: boolean;
+            queryTime?: boolean;
+            slowQueryThreshold?: string;
+        };
+    };
+    redis?: {
+        enabled?: boolean;
+    };
+    persistence?: {
+        enabled?: boolean;
+        flushInterval?: string;
+        retentionDays?: number;
+    };
+    alerts?: {
+        enabled?: boolean;
+        email?: {
+            enabled?: boolean;
+            recipients?: string[];
+        };
+        thresholds?: {
+            cpuPercent?: number;
+            memoryPercent?: number;
+            diskPercent?: number;
+            errorRatePercent?: number;
+            responseTimeMs?: number;
+            rateLimitBlocksPerMinute?: number;
+        };
+        cooldown?: string;
+    };
+}
+export interface MetricPoint {
+    timestamp: number;
+    metricType: MetricType;
+    metricName: string;
+    value: number;
+    tags?: Record<string, string>;
+}
+export type MetricType = "system" | "application" | "database" | "redis";
+export interface SystemMetrics {
+    cpu: {
+        usage: number;
+        cores: number;
+    };
+    memory: {
+        total: number;
+        used: number;
+        free: number;
+        usagePercent: number;
+        heapUsed: number;
+        heapTotal: number;
+    };
+    disk: {
+        total: number;
+        used: number;
+        free: number;
+        usagePercent: number;
+    };
+    network: {
+        bytesIn: number;
+        bytesOut: number;
+    };
+    process: {
+        uptime: number;
+        pid: number;
+        eventLoopLag: number;
+    };
+}
+export interface ApplicationMetrics {
+    requests: {
+        total: number;
+        perMinute: number;
+        byEndpoint: Record<string, number>;
+        byMethod: Record<string, number>;
+        byStatus: Record<string, number>;
+    };
+    responseTime: {
+        avg: number;
+        min: number;
+        max: number;
+        p50: number;
+        p95: number;
+        p99: number;
+    };
+    errors: {
+        total: number;
+        rate: number;
+        byType: Record<string, number>;
+    };
+    rateLimits: {
+        blocked: number;
+        blockedPerMinute: number;
+    };
+}
+export interface DatabaseMetrics {
+    connections: {
+        active: number;
+        idle: number;
+        total: number;
+    };
+    queries: {
+        total: number;
+        avgTime: number;
+        slowQueries: number;
+    };
+}
+export interface RedisMetrics {
+    memory: {
+        used: number;
+        peak: number;
+    };
+    connections: {
+        connected: number;
+    };
+    operations: {
+        totalCommands: number;
+        opsPerSec: number;
+    };
+    hitRate: number;
+}
+export interface AlertEvent {
+    id: string;
+    type: AlertType;
+    severity: "warning" | "critical";
+    message: string;
+    value: number;
+    threshold: number;
+    timestamp: number;
+    acknowledged: boolean;
+}
+export type AlertType = "cpu_high" | "memory_high" | "disk_high" | "error_rate_high" | "response_time_high" | "rate_limit_blocks_high";
+export interface MonitoringSnapshot {
+    timestamp: number;
+    system?: SystemMetrics;
+    application?: ApplicationMetrics;
+    database?: DatabaseMetrics;
+    redis?: RedisMetrics;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/Services/Notification/index.d.ts

@@ -0,0 +1,31 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { GmailService } from "../Gmail";
+import type { Logger } from "../Logger";
+import type { NotificationConfig, SendNotificationParams, TriggerNotificationParams } from "./types";
+export * from "./types";
+export interface NotificationServiceConfig {
+    db: NodePgDatabase;
+    schemaTables: Record<string, unknown>;
+    config: NotificationConfig;
+    logger: Logger;
+    gmailService?: GmailService;
+}
+export declare class NotificationService {
+    private db;
+    private schemaTables;
+    private config;
+    private logger;
+    private gmailService?;
+    constructor(serviceConfig: NotificationServiceConfig);
+    private getTable;
+    private getCol;
+    private interpolateTemplate;
+    triggerNotifications(params: TriggerNotificationParams): Promise<void>;
+    private resolveRecipients;
+    send(params: SendNotificationParams): Promise<void>;
+    private sendPortalNotification;
+    private sendEmailNotification;
+    markAsSeen(notificationId: string, userId: string): Promise<boolean>;
+    markAllAsSeen(userId: string): Promise<number>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/Services/Notification/types.d.ts

@@ -0,0 +1,59 @@
+export interface NotificationConfig {
+    enabled?: boolean;
+    portalEnabled?: boolean;
+    emailEnabled?: boolean;
+    defaultChannel?: "portal" | "email" | "both";
+    templateVariables?: Record<string, string>;
+}
+export declare const DEFAULT_NOTIFICATION_CONFIG: Required<NotificationConfig>;
+export type NotificationChannel = "portal" | "email" | "both";
+export type NotificationTrigger = "on_flow_started" | "on_step_reached" | "on_approved" | "on_rejected" | "on_flow_completed";
+export interface NotificationRule {
+    id: string;
+    flow_id: string;
+    step_node_id?: string;
+    trigger: NotificationTrigger;
+    channel: NotificationChannel;
+    title_template?: string;
+    body_template?: string;
+    starts_at?: Date;
+    expires_at?: Date;
+}
+export interface NotificationRecipient {
+    id: string;
+    rule_id: string;
+    recipient_type: "user" | "role" | "all_verifiers" | "step_verifier";
+    recipient_user_id?: string;
+    recipient_role_id?: string;
+    channel: NotificationChannel;
+}
+export interface Notification {
+    id: string;
+    user_id: string;
+    title: string;
+    body?: string;
+    entity_name?: string;
+    entity_id?: string;
+    is_seen: boolean;
+    seen_at?: Date;
+    created_at: Date;
+}
+export interface TriggerNotificationParams {
+    trigger: NotificationTrigger;
+    flow_id: string;
+    entity_name: string;
+    entity_id: string;
+    step_node_id?: string;
+    verifier_id?: string;
+    decision?: "approved" | "rejected";
+    context?: Record<string, unknown>;
+}
+export interface SendNotificationParams {
+    user_id: string;
+    title: string;
+    body?: string;
+    entity_name?: string;
+    entity_id?: string;
+    channel: NotificationChannel;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/Services/RateLimiter/index.d.ts

@@ -0,0 +1,99 @@
+import type { RedisManager } from "../../Managers/Redis";
+import type { Logger } from "../Logger";
+export interface RateLimitConfig {
+    enabled?: boolean;
+    strategy?: "sliding-window" | "fixed-window" | "token-bucket";
+    keyPrefix?: string;
+    authRoutes?: {
+        window?: string;
+        max?: number;
+        login?: {
+            window?: string;
+            max?: number;
+            blockDuration?: string;
+        };
+        register?: {
+            window?: string;
+            max?: number;
+            blockDuration?: string;
+        };
+        passwordReset?: {
+            window?: string;
+            max?: number;
+            blockDuration?: string;
+        };
+        magicLink?: {
+            window?: string;
+            max?: number;
+            blockDuration?: string;
+        };
+    };
+    publicRoutes?: {
+        window?: string;
+        max?: number;
+    };
+    privateRoutes?: {
+        window?: string;
+        max?: number;
+    };
+    byIp?: boolean;
+    byUserId?: boolean;
+    byEndpoint?: boolean;
+    skipSuccessfulRequests?: boolean;
+    headers?: {
+        remaining?: string;
+        reset?: string;
+        limit?: string;
+    };
+    whitelist?: string[];
+    blacklist?: string[];
+}
+export interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+    limit: number;
+    retryAfter?: number;
+}
+export type RouteCategory = "auth" | "public" | "private";
+export type AuthRouteType = "login" | "register" | "passwordReset" | "magicLink" | "other";
+interface RateLimiterDeps {
+    redis: RedisManager;
+    logger: Logger;
+    config: RateLimitConfig;
+}
+export declare class RateLimiter {
+    private redis;
+    private logger;
+    private config;
+    constructor(deps: RateLimiterDeps);
+    private mergeConfig;
+    private parseTimeToMs;
+    private buildKey;
+    private getLimits;
+    isWhitelisted(ip: string): boolean;
+    isBlacklisted(ip: string): boolean;
+    private readRedis;
+    check(params: {
+        ip: string;
+        userId?: string;
+        endpoint: string;
+        category: RouteCategory;
+        authType?: AuthRouteType;
+    }): Promise<RateLimitResult>;
+    private slidingWindowCheck;
+    private fixedWindowCheck;
+    private tokenBucketCheck;
+    decrement(params: {
+        ip: string;
+        userId?: string;
+        endpoint: string;
+        category: RouteCategory;
+        authType?: AuthRouteType;
+    }): Promise<void>;
+    getHeaders(result: RateLimitResult): Record<string, string>;
+    isEnabled(): boolean;
+}
+export declare function createRateLimiter(deps: RateLimiterDeps): RateLimiter;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/Services/Verification/index.d.ts

@@ -0,0 +1,23 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { Logger } from "../Logger";
+import type { DecideParams, DecideResult, PendingVerification, VerificationConfig, VerificationStatus } from "./types";
+export * from "./types";
+export interface VerificationServiceConfig {
+    db: NodePgDatabase;
+    schemaTables: Record<string, unknown>;
+    config: VerificationConfig;
+    logger: Logger;
+}
+export declare class VerificationService {
+    private db;
+    private schemaTables;
+    private config;
+    private logger;
+    constructor(serviceConfig: VerificationServiceConfig);
+    private getTable;
+    private getCol;
+    getStatus(entityName: string, entityId: string): Promise<VerificationStatus>;
+    decide(params: DecideParams): Promise<DecideResult>;
+    getPending(userId: string): Promise<PendingVerification[]>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/Services/Verification/types.d.ts

@@ -0,0 +1,135 @@
+export interface VerificationConfig {
+    enabled?: boolean;
+    autoResetOnRejection?: boolean;
+    requireSignatureByDefault?: boolean;
+    diffTrackingEnabled?: boolean;
+    endpoints?: {
+        enabled?: boolean;
+        basePath?: string;
+    };
+}
+export declare const DEFAULT_VERIFICATION_CONFIG: Required<VerificationConfig>;
+export type VerificationDecision = "approved" | "rejected" | "pending";
+export type VerificationTrigger = "on_flow_started" | "on_step_reached" | "on_approved" | "on_rejected" | "on_flow_completed";
+export type FlowTriggerOn = "create" | "update" | "delete" | "manual";
+export type NodeType = "start" | "step" | "condition" | "notification" | "end";
+export type EdgeType = "default" | "conditional" | "success" | "failure";
+export interface VerificationFlow {
+    id: string;
+    entity_name: string;
+    name: string;
+    description?: string;
+    trigger_on: FlowTriggerOn;
+    trigger_fields?: string[];
+    is_draft: boolean;
+    published_at?: Date;
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    created_at: Date;
+    updated_at: Date;
+}
+export interface VerificationStep {
+    id: string;
+    flow_id: string;
+    entity_name: string;
+    node_id: string;
+    node_type: NodeType;
+    step_order: number;
+    name?: string;
+    description?: string;
+    position_x: number;
+    position_y: number;
+    width?: number;
+    height?: number;
+    style?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+}
+export interface VerificationEdge {
+    id: string;
+    flow_id: string;
+    edge_id: string;
+    source_node_id: string;
+    target_node_id: string;
+    source_handle?: string;
+    target_handle?: string;
+    edge_type: EdgeType;
+    label?: string;
+    condition?: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    animated: boolean;
+}
+export interface Verification {
+    id: string;
+    requirement_id: string;
+    verifier_id: string;
+    signature_id?: string;
+    entity_name: string;
+    entity_id: string;
+    step_order: number;
+    decision: VerificationDecision;
+    reason?: string;
+    diff?: Record<string, unknown>;
+    created_at: Date;
+    updated_at: Date;
+}
+export interface VerificationRequirement {
+    id: string;
+    entity_id?: string;
+    entity_name?: string;
+    verifier_type: "user" | "role" | "entity_creator";
+    verifier_id?: string;
+    verifier_role?: string;
+    is_signature_mandatory: boolean;
+    step_order: number;
+    is_all_required: boolean;
+    connected_from_step_order?: number;
+    position_x?: number;
+    position_y?: number;
+}
+export interface VerificationStatus {
+    entity_name: string;
+    entity_id: string;
+    flow: VerificationFlow | null;
+    current_step: number;
+    total_steps: number;
+    is_completed: boolean;
+    is_rejected: boolean;
+    verifications: Verification[];
+    pending_verifiers: {
+        step_order: number;
+        verifier_type: string;
+        verifier_id?: string;
+        verifier_role?: string;
+        is_signature_mandatory: boolean;
+    }[];
+}
+export interface DecideParams {
+    entity_name: string;
+    entity_id: string;
+    user_id: string;
+    decision: "approved" | "rejected";
+    reason?: string;
+    signature_id?: string;
+    diff?: Record<string, unknown>;
+}
+export interface DecideResult {
+    success: boolean;
+    message: string;
+    verification?: Verification;
+    flow_completed?: boolean;
+    next_step?: number;
+}
+export interface PendingVerification {
+    entity_name: string;
+    entity_id: string;
+    flow_name: string;
+    step_order: number;
+    step_name?: string;
+    is_signature_mandatory: boolean;
+    created_at: Date;
+    diff?: Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/Services/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./Auth";
+export * from "./Authorization";
+export * from "./Captcha";
+export * from "./Gmail";
+export * from "./Logger";
+export * from "./Monitoring";
+export * from "./Notification";
+export * from "./RateLimiter";
+export * from "./Verification";
+//# sourceMappingURL=index.d.ts.map