nucleus-core-ts 0.8.0

package/dist/src/ElysiaPlugin/routes/auth/types.d.ts

@@ -0,0 +1,153 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { Logger } from "src/Services";
+export interface AuthRouteConfig {
+    db: NodePgDatabase | null;
+    logger: Logger;
+    authentication?: {
+        enabled?: boolean;
+        accessToken?: {
+            secret?: string;
+            expiresIn?: string;
+            name?: string;
+        };
+        refreshToken?: {
+            secret?: string;
+            expiresIn?: string;
+            name?: string;
+        };
+        sessionToken?: {
+            secret?: string;
+            expiresIn?: string;
+            name?: string;
+        };
+    };
+    usersTable: ReturnType<typeof import("drizzle-orm/pg-core").pgTable> | null;
+    sessionsTable?: ReturnType<typeof import("drizzle-orm/pg-core").pgTable> | null;
+}
+export interface LoginConfig {
+    route?: string;
+    rememberMe: boolean;
+    isPublic: boolean;
+    enabled: boolean;
+}
+export interface EmailVerificationConfig {
+    enabled?: boolean;
+    provider?: "gmail";
+    tokenExpiresIn?: string;
+    redirectUrl?: string;
+    resendCooldown?: string;
+    maxResendAttempts?: number;
+    templates?: {
+        verification?: {
+            subject?: string;
+            htmlTemplatePath?: string;
+        };
+        welcome?: {
+            enabled?: boolean;
+            subject?: string;
+            htmlTemplatePath?: string;
+        };
+    };
+}
+export interface RegisterConfig {
+    route?: string;
+    isPublic: boolean;
+    enabled: boolean;
+    emailVerification?: EmailVerificationConfig;
+}
+export interface LogoutConfig {
+    route?: string;
+    isPublic: boolean;
+    enabled: boolean;
+}
+export interface RefreshConfig {
+    route?: string;
+    isPublic: boolean;
+    enabled: boolean;
+}
+export interface PasswordResetConfig {
+    route?: string;
+    isPublic: boolean;
+    enabled: boolean;
+}
+export interface PasswordChangeConfig {
+    route?: string;
+    isPublic: boolean;
+    enabled: boolean;
+}
+export interface PasswordSetConfig {
+    route?: string;
+    isPublic: boolean;
+    enabled: boolean;
+}
+export interface SessionsConfig {
+    route?: string;
+    isPublic: boolean;
+    enabled: boolean;
+    maxActiveSessions?: number;
+    inactivityTimeout?: string;
+    allowMultipleDevices?: boolean;
+    trustNewDevices?: boolean;
+    notifyOnNewDevice?: boolean;
+}
+export interface MagicLinkConfig {
+    route?: string;
+    verifyRoute?: string;
+    isPublic: boolean;
+    enabled: boolean;
+    expiresIn?: string;
+    redirectUrl?: string;
+}
+export interface MeConfig {
+    route?: string;
+    isPublic?: boolean;
+    enabled?: boolean;
+    includeProfile?: boolean;
+    includeAddresses?: boolean;
+    includePhones?: boolean;
+    includeFiles?: boolean;
+}
+export interface InviteConfig {
+    route?: string;
+    isPublic?: boolean;
+    enabled: boolean;
+    tokenExpiresIn?: string;
+    redirectUrl?: string;
+}
+export interface CaptchaConfig {
+    route?: string;
+    isPublic?: boolean;
+    enabled: boolean;
+    type?: "math" | "image" | "puzzle" | "text";
+    difficulty?: "easy" | "medium" | "hard";
+    expiresIn?: string;
+    maxAttempts?: number;
+    caseSensitive?: boolean;
+}
+export interface AuthFeatureConfigs {
+    login?: LoginConfig;
+    register?: RegisterConfig;
+    logout?: LogoutConfig;
+    refresh?: RefreshConfig;
+    passwordReset?: PasswordResetConfig;
+    passwordChange?: PasswordChangeConfig;
+    passwordSet?: PasswordSetConfig;
+    sessions?: SessionsConfig;
+    magicLink?: MagicLinkConfig;
+    me?: MeConfig;
+    invite?: InviteConfig;
+    captcha?: CaptchaConfig;
+}
+export interface TokenPayload {
+    sub: string;
+    iat: number;
+    exp: number;
+    type: "access" | "refresh";
+}
+export interface SessionData {
+    userId: string;
+    email?: string;
+    createdAt: string;
+    expiresAt: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/ElysiaPlugin/routes/entity/index.d.ts

@@ -0,0 +1,5 @@
+import { Elysia } from "elysia";
+import type { EntityRouteConfig } from "./types";
+export type { EntityRouteConfig } from "./types";
+export declare function createEntityRoutes<T extends Elysia>(app: T, config: EntityRouteConfig): T;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/ElysiaPlugin/routes/entity/types.d.ts

@@ -0,0 +1,50 @@
+import type { NucleusTable } from "@types";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { Logger } from "src/Services";
+export interface EntityRouteConfig {
+    db: NodePgDatabase | null;
+    schemaTables: Record<string, unknown>;
+    schemaRelations: Record<string, unknown>;
+    entities: NucleusTable[];
+    logger: Logger;
+    databaseUrl?: string;
+    storage?: {
+        enabled?: boolean;
+        basePath?: string;
+        maxFileSizeBytes?: number;
+        allowedMimeTypes?: string[];
+        blockedMimeTypes?: string[];
+        formData?: {
+            filesField?: string;
+            dataField?: string;
+            maxFiles?: number;
+        };
+    };
+    authorization?: {
+        enabled?: boolean;
+        skipTables?: string[];
+        skipColumns?: string[];
+    };
+    emailServiceAvailable?: boolean;
+}
+export interface QueryParams {
+    page?: number;
+    limit?: number;
+    offset?: number;
+    search?: string;
+    searchFields?: string[];
+    sort?: {
+        field: string;
+        direction: "asc" | "desc";
+    }[];
+    filters?: {
+        field: string;
+        operator: string;
+        value: unknown;
+    }[];
+    with?: {
+        name: string;
+        limit?: number;
+    }[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/ElysiaPlugin/routes/entity/utils.d.ts

@@ -0,0 +1,11 @@
+import type { NucleusTable } from "@types";
+import { type TSchema } from "elysia";
+export declare function buildBodySchemaFromEntityColumns(entityColumns: NucleusTable["columns"]): TSchema;
+export declare function createBulkUpdateSchema(entityColumns: NucleusTable["columns"]): TSchema;
+export declare function buildResponseSchemaFromEntityColumns(entityColumns: NucleusTable["columns"], drizzleTable?: Record<string, unknown>): TSchema;
+export declare function buildListResponseSchema(entityColumns: NucleusTable["columns"], drizzleTable?: Record<string, unknown>): TSchema;
+export declare function buildSingleResponseSchema(entityColumns: NucleusTable["columns"], drizzleTable?: Record<string, unknown>): TSchema;
+export declare function buildErrorResponseSchema(): TSchema;
+export declare function buildBulkResponseSchema(entityColumns: NucleusTable["columns"], drizzleTable?: Record<string, unknown>): TSchema;
+export declare function buildDeleteResponseSchema(): TSchema;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/ElysiaPlugin/routes/index.d.ts

@@ -0,0 +1,5 @@
+export type { AuthFeatureConfigs, AuthRouteConfig, AuthRoutesConfig, LoginConfig, LogoutConfig, PasswordChangeConfig, PasswordResetConfig, RefreshConfig, RegisterConfig, } from "./auth";
+export { createAuthRoutes } from "./auth";
+export type { EntityRouteConfig } from "./entity";
+export { createEntityRoutes } from "./entity";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/ElysiaPlugin/routes/monitoring/index.d.ts

@@ -0,0 +1,58 @@
+import Elysia from "elysia";
+import type { Logger } from "../../../Services/Logger";
+import type { MonitoringService } from "../../../Services/Monitoring";
+export interface MonitoringRoutesConfig {
+    monitoringService: MonitoringService;
+    logger: Logger;
+    endpoints: {
+        enabled: boolean;
+        basePath: string;
+        stream: {
+            enabled: boolean;
+            path: string;
+            interval: string;
+        };
+        snapshot: {
+            enabled: boolean;
+            path: string;
+        };
+        history: {
+            enabled: boolean;
+            path: string;
+            maxMinutes: number;
+        };
+        alerts: {
+            enabled: boolean;
+            path: string;
+        };
+    };
+}
+export declare function createMonitoringRoutes(config: MonitoringRoutesConfig): Elysia<string, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/ElysiaPlugin/routes/storage/cdn.d.ts

@@ -0,0 +1,51 @@
+import Elysia from "elysia";
+import type { Logger } from "../../../Services/Logger";
+export interface CdnConfig {
+    enabled: boolean;
+    basePath: string;
+    cacheMaxAge: number;
+    enableRangeRequests: boolean;
+    enableEtag: boolean;
+    corsOrigins: string[];
+}
+export interface CdnRoutesConfig {
+    cdn: CdnConfig;
+    storagePath: string;
+    logger: Logger;
+    getFileRecord?: (id: string, schemaName?: string) => Promise<{
+        id: string;
+        name: string;
+        path: string;
+        mime_type: string;
+    } | null>;
+}
+export declare function mergeCdnConfig(config?: Partial<CdnConfig>): CdnConfig;
+export declare function createCdnRoutes(config: CdnRoutesConfig): Elysia<string, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=cdn.d.ts.map

package/dist/src/ElysiaPlugin/routes/storage/helpers.d.ts

@@ -0,0 +1,53 @@
+export interface StorageConfig {
+    enabled: boolean;
+    basePath: string;
+    maxFileSizeBytes: number;
+    allowedMimeTypes: string[];
+    blockedMimeTypes: string[];
+    formData: {
+        filesField: string;
+        dataField: string;
+        maxFiles: number;
+    };
+}
+export interface StorageConfigInput {
+    enabled?: boolean;
+    basePath?: string;
+    maxFileSizeBytes?: number;
+    allowedMimeTypes?: string[];
+    blockedMimeTypes?: string[];
+    formData?: {
+        filesField?: string;
+        dataField?: string;
+        maxFiles?: number;
+    };
+}
+export interface FileUploadResult {
+    id: string;
+    name: string;
+    originalName: string;
+    path: string;
+    mimeType: string;
+    size: number;
+    createdAt: Date;
+}
+export interface FormDataParseResult {
+    data: Record<string, unknown>;
+    files: File[];
+}
+export declare function mergeStorageConfig(config?: StorageConfigInput): StorageConfig;
+export declare function parseFormDataBody(body: unknown, config: StorageConfig): FormDataParseResult;
+export declare function validateFile(file: File, config: StorageConfig): {
+    valid: boolean;
+    error?: string;
+};
+export declare function uploadFile(file: File, config: StorageConfig, subFolder?: string): Promise<FileUploadResult>;
+export declare function uploadFiles(files: File[], config: StorageConfig, subFolder?: string): Promise<{
+    success: FileUploadResult[];
+    failed: {
+        file: string;
+        error: string;
+    }[];
+}>;
+export declare function deleteFile(filePath: string, fileName: string): Promise<boolean>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/src/ElysiaPlugin/routes/storage/index.d.ts

@@ -0,0 +1,3 @@
+export { type CdnConfig, type CdnRoutesConfig, createCdnRoutes, mergeCdnConfig, } from "./cdn";
+export { deleteFile, type FileUploadResult, type FormDataParseResult, mergeStorageConfig, parseFormDataBody, type StorageConfig, type StorageConfigInput, uploadFile, uploadFiles, validateFile, } from "./helpers";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/ElysiaPlugin/routes/verification/index.d.ts

@@ -0,0 +1,39 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { Elysia } from "elysia";
+import type { Logger } from "src/Services/Logger";
+import { type VerificationConfig } from "src/Services/Verification";
+export interface VerificationRoutesConfig {
+    db: NodePgDatabase;
+    schemaTables: Record<string, unknown>;
+    config: VerificationConfig;
+    logger: Logger;
+}
+export declare function createVerificationRoutes(routeConfig: VerificationRoutesConfig): Elysia<string, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/ElysiaPlugin/swagger.d.ts

@@ -0,0 +1,28 @@
+import type { NucleusSwaggerConfig } from "@types";
+export type { NucleusSwaggerConfig } from "@types";
+export declare function createSwaggerPlugin(config?: NucleusSwaggerConfig): import("elysia").default<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}> | null;
+//# sourceMappingURL=swagger.d.ts.map

package/dist/src/ElysiaPlugin/utils.d.ts

@@ -0,0 +1,70 @@
+import { RedisManager } from "@managers";
+import type { AuditPayload, NucleusColumn, NucleusConfigOptions, TokenNames, TokenValues } from "@types";
+import type { SessionRecord } from "src/Services/Auth/SessionStore/types";
+export declare function parseTokenValuesFromHeaders(headers: Headers, tokenNames: TokenNames): TokenValues;
+export declare function initiateRedisManager(config: NucleusConfigOptions): void;
+export declare function getRedisManager(): RedisManager | null;
+export declare function parseTimeToSeconds(timeString: string | number): number;
+export declare function signNewAccessToken({ sessionData, options, refreshTokenId, }: {
+    sessionData: SessionRecord;
+    options: NucleusConfigOptions;
+    refreshTokenId: string;
+}): string;
+export declare function toAudit(payload: AuditPayload | null, summary: string): {
+    entityName: string;
+    entityId: string | null;
+    operation: string;
+    userId: string | null;
+    summary: string;
+    ipAddress: string;
+    userAgent: string;
+    path: string;
+    query: string;
+} | undefined;
+import type { PaginationMeta, StandardQueryParams } from "@types";
+export declare function parseQueryParams(query: Record<string, unknown>): StandardQueryParams;
+export declare function buildPaginationMeta(page: number, limit: number, offset: number, totalItems: number): PaginationMeta;
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+export declare function validatePayload(payload: Record<string, unknown>, columns: NucleusColumn[], isPartial?: boolean): ValidationResult;
+export declare function sanitizePayload(payload: Record<string, unknown>, columns: NucleusColumn[]): Record<string, unknown>;
+export interface AuditLogEntry {
+    user_id: string;
+    entity_name: string;
+    entity_id: string | null;
+    operation: "CREATE" | "UPDATE" | "DELETE";
+    old_data?: Record<string, unknown> | null;
+    new_data?: Record<string, unknown> | null;
+    timestamp: string;
+}
+export declare function createAuditLog(db: unknown, auditTable: unknown, entry: Omit<AuditLogEntry, "timestamp">): void;
+export interface RefreshTokenResult {
+    success: boolean;
+    accessToken?: string;
+    fromCache?: boolean;
+    error?: string;
+}
+export declare function refreshAccessTokenWithLock(userId: string, sessionId: string, generateToken: () => string): Promise<RefreshTokenResult>;
+export interface EnvValidationError {
+    field: string;
+    envName: string;
+    message: string;
+}
+export declare function validateEnvVariables(config: NucleusConfigOptions): {
+    valid: boolean;
+    errors: EnvValidationError[];
+    resolved: {
+        databaseUrl?: string;
+        redisUrl?: string;
+        accessTokenSecret?: string;
+        refreshTokenSecret?: string;
+        sessionTokenSecret?: string;
+    };
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/Managers/Dapr/clients/binding-client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Binding client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import type { BindingOptions, DaprLogger } from "../types";
+export declare class DaprBindingClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Invoke an output binding
+     */
+    invoke<TData = unknown, TResponse = unknown>(name: string, operation: string, data?: TData, options?: BindingOptions): Promise<TResponse>;
+}
+//# sourceMappingURL=binding-client.d.ts.map

package/dist/src/Managers/Dapr/clients/config-client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Configuration client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import type { ConfigItem, ConfigSubscription, ConfigSubscriptionCallback, DaprLogger } from "../types";
+export declare class DaprConfigClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Get configuration items by keys
+     */
+    get(keys: string[], storeName?: string): Promise<Record<string, ConfigItem>>;
+    /**
+     * Subscribe to configuration updates for specific keys
+     */
+    subscribeWithKeys(keys: string[], callback: ConfigSubscriptionCallback, storeName?: string): Promise<ConfigSubscription>;
+    /**
+     * Get a single configuration value by key
+     */
+    getValue(key: string, storeName?: string): Promise<string | undefined>;
+    /**
+     * Get multiple configuration values as a simple key-value object
+     */
+    getValues(keys: string[], storeName?: string): Promise<Record<string, string>>;
+}
+//# sourceMappingURL=config-client.d.ts.map

package/dist/src/Managers/Dapr/clients/crypto-client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Cryptography client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import type { CryptoOptions, DaprLogger } from "../types";
+export declare class DaprCryptoClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Encrypt data using a Dapr crypto component
+     */
+    encrypt(data: Buffer | string, options: CryptoOptions): Promise<Buffer>;
+    /**
+     * Decrypt data using a Dapr crypto component
+     */
+    decrypt(data: Buffer | string, options: CryptoOptions): Promise<Buffer>;
+    /**
+     * Encrypt a string and return a base64 encoded string
+     */
+    encryptString(plaintext: string, options: CryptoOptions): Promise<string>;
+    /**
+     * Decrypt a base64 encoded string and return the original string
+     */
+    decryptString(ciphertext: string, options: CryptoOptions): Promise<string>;
+}
+//# sourceMappingURL=crypto-client.d.ts.map

package/dist/src/Managers/Dapr/clients/invoke-client.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Service invocation client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import { HttpMethod } from "@dapr/dapr";
+import type { DaprLogger, InvokeOptions } from "../types";
+export declare class DaprInvokeClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Invoke a service method
+     */
+    invoke<TRequest extends object = object, TResponse = unknown>(appId: string, methodName: string, httpMethod?: HttpMethod, data?: TRequest, options?: InvokeOptions): Promise<TResponse>;
+    /**
+     * Invoke a service with GET method (convenience method)
+     */
+    get<TResponse = unknown>(appId: string, methodName: string, options?: InvokeOptions): Promise<TResponse>;
+    /**
+     * Invoke a service with POST method (convenience method)
+     */
+    post<TRequest extends object = Record<string, unknown>, TResponse = unknown>(appId: string, methodName: string, data?: TRequest, options?: InvokeOptions): Promise<TResponse>;
+    /**
+     * Invoke a service with PUT method (convenience method)
+     */
+    put<TRequest extends object = Record<string, unknown>, TResponse = unknown>(appId: string, methodName: string, data?: TRequest, options?: InvokeOptions): Promise<TResponse>;
+    /**
+     * Invoke a service with DELETE method (convenience method)
+     */
+    delete<TResponse = unknown>(appId: string, methodName: string, options?: InvokeOptions): Promise<TResponse>;
+}
+//# sourceMappingURL=invoke-client.d.ts.map

package/dist/src/Managers/Dapr/clients/lock-client.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Distributed lock client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import type { DaprLogger, LockOptions, LockResponse, UnlockResponse } from "../types";
+export declare class DaprLockClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Try to acquire a lock
+     */
+    lock(storeName: string, resourceId: string, lockOwner: string, options: LockOptions): Promise<LockResponse>;
+    /**
+     * Release a previously acquired lock
+     */
+    unlock(storeName: string, resourceId: string, lockOwner: string): Promise<UnlockResponse>;
+    /**
+     * Get a readable name for a lock status code
+     */
+    private getLockStatusName;
+}
+//# sourceMappingURL=lock-client.d.ts.map