nucleus-core-ts 0.8.0

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

@@ -0,0 +1,23 @@
+/**
+ * PubSub client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import type { BulkPublishMessage, BulkPublishResponse, DaprLogger, PublishOptions } from "../types";
+export declare class DaprPubSubClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Publish a message to a topic
+     */
+    publish<T extends object | string>(topic: string, data: T, options?: PublishOptions, pubsubName?: string): Promise<void>;
+    /**
+     * Publish multiple messages to a topic in a single request
+     */
+    publishBulk<T extends object | string>(topic: string, messages: T[] | BulkPublishMessage<T>[], pubsubName?: string): Promise<BulkPublishResponse>;
+    /**
+     * Create a bulk publish message with proper structure
+     */
+    createBulkPublishMessage<T = unknown>(event: T, entryId: string, contentType?: string, metadata?: Record<string, string>): BulkPublishMessage<T>;
+}
+//# sourceMappingURL=pubsub-client.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * Secret client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import type { DaprLogger, SecretOptions } from "../types";
+export declare class DaprSecretClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Get a secret by key
+     */
+    get<T = string>(key: string, options?: SecretOptions, storeName?: string): Promise<T>;
+    /**
+     * Get all secrets in the store
+     */
+    getBulk<T = Record<string, string>>(_options?: SecretOptions, storeName?: string): Promise<T>;
+}
+//# sourceMappingURL=secret-client.d.ts.map

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

@@ -0,0 +1,55 @@
+/**
+ * State management client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+type StateQueryType = {
+    filter: Record<string, unknown>;
+    sort: {
+        key: string;
+        order?: "ASC" | "DESC";
+    }[];
+    page: {
+        limit: number;
+        token?: string;
+    };
+};
+import type { DaprLogger, StateItem, StateOperation, StateSaveOptions } from "../types";
+export declare class DaprStateClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Save state items
+     */
+    save<T = unknown>(stateItems: StateItem<T>[], options?: StateSaveOptions, storeName?: string): Promise<void>;
+    /**
+     * Get a state item by key
+     */
+    get<T = unknown>(key: string, storeName?: string): Promise<T | undefined>;
+    /**
+     * Get multiple state items by keys
+     */
+    getBulk<T = unknown>(keys: string[], storeName?: string): Promise<Record<string, T>>;
+    /**
+     * Delete a state item by key
+     */
+    delete(key: string, etag?: string, metadata?: Record<string, string>, storeName?: string): Promise<void>;
+    /**
+     * Execute state transactions
+     */
+    transaction<T = unknown>(operations: StateOperation<T>[], storeName?: string): Promise<void>;
+    /**
+     * Query state store
+     */
+    query<T = unknown>(query: StateQueryType, storeName?: string): Promise<T[]>;
+    /**
+     * Save a single state item (convenience method)
+     */
+    saveItem<T = unknown>(key: string, value: T, options?: StateSaveOptions, storeName?: string): Promise<void>;
+    /**
+     * Update a state item if it exists, otherwise create it
+     */
+    upsert<T = unknown>(key: string, value: T, options?: StateSaveOptions, storeName?: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=state-client.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * Workflow client for Dapr
+ */
+import type { DaprClient } from "@dapr/dapr";
+import type { DaprLogger, WorkflowInstance, WorkflowOptions } from "../types";
+export declare class DaprWorkflowClient {
+    private client;
+    private logger;
+    constructor(clientProvider: () => Promise<DaprClient>, logger: DaprLogger);
+    /**
+     * Start a new workflow instance
+     */
+    start<T = unknown>(workflowName: string, input?: T, options?: WorkflowOptions): Promise<string>;
+    /**
+     * Get a workflow instance by ID
+     */
+    get(instanceId: string): Promise<WorkflowInstance>;
+    /**
+     * Terminate a workflow instance
+     */
+    terminate(instanceId: string): Promise<void>;
+    /**
+     * Pause a workflow instance
+     */
+    pause(instanceId: string): Promise<void>;
+    /**
+     * Resume a paused workflow instance
+     */
+    resume(instanceId: string): Promise<void>;
+    /**
+     * Purge a workflow instance
+     */
+    purge(instanceId: string): Promise<void>;
+    /**
+     * Raise an event for a workflow instance
+     */
+    raiseEvent<T = unknown>(instanceId: string, eventName: string, eventData?: T): Promise<void>;
+}
+//# sourceMappingURL=workflow-client.d.ts.map

package/dist/src/Managers/Dapr/connection-manager.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Connection manager for Dapr
+ */
+import { DaprClient } from "@dapr/dapr";
+import type { DaprConnectionOptions, HealthStatus } from "./types";
+export declare class DaprConnectionManager {
+    private client;
+    private daprHost;
+    private daprPort;
+    private communicationProtocol;
+    private maxBodySizeMb;
+    private daprApiToken?;
+    private logger;
+    private connectionStatus;
+    private connectionPromise;
+    constructor(options?: DaprConnectionOptions);
+    /**
+     * Get the current Dapr client instance
+     * If not connected, it will connect automatically
+     */
+    getClient(): Promise<DaprClient>;
+    /**
+     * Connect to Dapr sidecar
+     */
+    connect(): Promise<void>;
+    /**
+     * Establish connection to Dapr sidecar
+     */
+    private establishConnection;
+    /**
+     * Disconnect from Dapr sidecar
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected to Dapr sidecar
+     */
+    isConnected(): boolean;
+    /**
+     * Get connection status
+     */
+    getConnectionStatus(): string;
+    /**
+     * Perform a health check on the Dapr sidecar
+     */
+    healthCheck(): Promise<HealthStatus>;
+    /**
+     * Get the Dapr client configuration
+     */
+    getClientConfig(): Record<string, any>;
+}
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/src/Managers/Dapr/constants.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Constants for the Dapr manager
+ */
+export declare const DEFAULT_DAPR_HOST = "127.0.0.1";
+export declare const DEFAULT_DAPR_PORT = "3500";
+export declare const DEFAULT_DAPR_GRPC_PORT = "50001";
+export declare const DEFAULT_MAX_BODY_SIZE_MB = 4;
+export declare const DEFAULT_STATE_STORE = "statestore-redis";
+export declare const DEFAULT_PUBSUB_NAME = "pubsub-rabbitmq";
+export declare const DEFAULT_SECRET_STORE = "secretstore";
+export declare const DEFAULT_CONFIG_STORE = "configstore-redis";
+export declare const ENV_DAPR_HOST = "DAPR_HOST";
+export declare const ENV_DAPR_HTTP_PORT = "DAPR_HTTP_PORT";
+export declare const ENV_DAPR_GRPC_PORT = "DAPR_GRPC_PORT";
+export declare const ENV_DAPR_HTTP_ENDPOINT = "DAPR_HTTP_ENDPOINT";
+export declare const ENV_DAPR_GRPC_ENDPOINT = "DAPR_GRPC_ENDPOINT";
+export declare const ENV_DAPR_API_TOKEN = "DAPR_API_TOKEN";
+export declare const DEFAULT_RETRY_COUNT = 3;
+export declare const DEFAULT_RETRY_DELAY_MS = 500;
+export declare const DEFAULT_RETRY_MAX_DELAY_MS = 5000;
+export declare const DEFAULT_RETRY_JITTER = 0.1;
+export declare const DEFAULT_OPERATION_TIMEOUT_MS = 30000;
+export declare const DEFAULT_CONNECTION_TIMEOUT_MS = 10000;
+export declare const DEFAULT_HEALTH_CHECK_TIMEOUT_MS = 5000;
+export declare const CONNECTION_STATUS: {
+    readonly CONNECTED: "connected";
+    readonly DISCONNECTED: "disconnected";
+    readonly CONNECTING: "connecting";
+    readonly ERROR: "error";
+};
+export declare const HEALTH_STATUS: {
+    readonly HEALTHY: "healthy";
+    readonly UNHEALTHY: "unhealthy";
+};
+export declare const ERROR_CODES: {
+    readonly CONNECTION_ERROR: "DAPR_CONNECTION_ERROR";
+    readonly TIMEOUT_ERROR: "DAPR_TIMEOUT_ERROR";
+    readonly STATE_ERROR: "DAPR_STATE_ERROR";
+    readonly PUBSUB_ERROR: "DAPR_PUBSUB_ERROR";
+    readonly BINDING_ERROR: "DAPR_BINDING_ERROR";
+    readonly SECRET_ERROR: "DAPR_SECRET_ERROR";
+    readonly CONFIG_ERROR: "DAPR_CONFIG_ERROR";
+    readonly INVOKE_ERROR: "DAPR_INVOKE_ERROR";
+    readonly CRYPTO_ERROR: "DAPR_CRYPTO_ERROR";
+    readonly LOCK_ERROR: "DAPR_LOCK_ERROR";
+    readonly WORKFLOW_ERROR: "DAPR_WORKFLOW_ERROR";
+    readonly VALIDATION_ERROR: "DAPR_VALIDATION_ERROR";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/Managers/Dapr/dapr-manager.d.ts

@@ -0,0 +1,160 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: <> */
+import { HttpMethod } from "@dapr/dapr";
+type StateQueryType = {
+    filter: any;
+    sort: {
+        key: string;
+        order?: "ASC" | "DESC";
+    }[];
+    page: {
+        limit: number;
+        token?: string;
+    };
+};
+export declare class DaprConnectionManager {
+    private client;
+    private daprHost;
+    private daprPort;
+    constructor();
+    /**
+     * Connect to Dapr (reinitialize client)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from Dapr
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected to Dapr
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * Save state
+     */
+    addState(key: string, value: any, storeName?: string): Promise<any>;
+    /**
+     * Update state (alias for addState since Dapr treats them the same)
+     */
+    updateState(key: string, value: any, storeName?: string): Promise<any>;
+    /**
+     * Get state by key
+     */
+    getState(key: string, storeName?: string): Promise<any>;
+    /**
+     * Delete state
+     */
+    deleteState(key: string, storeName?: string): Promise<any>;
+    /**
+     * Query states
+     */
+    queryStates(query: StateQueryType, storeName?: string): Promise<any>;
+    /**
+     * Get multiple states
+     */
+    getBulkState(keys: string[], storeName?: string): Promise<any>;
+    /**
+     * Execute state transaction
+     */
+    stateTransaction(operations: any[], storeName?: string): Promise<any>;
+    /**
+     * Get configuration
+     */
+    getConfig(keys: string[], storeName?: string): Promise<any>;
+    /**
+     * Publish message
+     */
+    publishMessage(pubsubName: string, topicName: string, data: any, options?: {
+        contentType?: string;
+        metadata?: Record<string, string>;
+    }): Promise<any>;
+    /**
+     * Invoke another service
+     */
+    invokeService(appId: string, methodName: string, httpMethod?: HttpMethod, data?: any, options?: {
+        headers?: Record<string, string>;
+    }): Promise<any>;
+    /**
+     * Get secret
+     */
+    getSecret(storeName: string, key: string, metadata?: Record<string, string>): Promise<any>;
+    /**
+     * Get bulk secrets
+     */
+    getBulkSecrets(storeName: string, _metadata?: Record<string, string>): Promise<any>;
+    /**
+     * Invoke binding
+     */
+    invokeBinding(name: string, operation: string, data?: any, metadata?: Record<string, string>): Promise<any>;
+    /**
+     * Perform health check by making a simple state call
+     */
+    healthCheck(): Promise<{
+        status: string;
+        timestamp: string;
+    }>;
+    /**
+     * Test connection with comprehensive checks
+     * Performs multiple operations to verify Dapr functionality
+     */
+    testConnection(): Promise<{
+        success: boolean;
+        operations: Record<string, boolean>;
+        error?: string;
+    }>;
+    /**
+     * Try to acquire a lock
+     */
+    tryLock(storeName: string, resourceId: string, lockOwner: string, expiryInSeconds?: number): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Release a lock
+     */
+    unlock(storeName: string, resourceId: string, lockOwner: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Encrypt data using Dapr crypto
+     */
+    encrypt(componentName: string, keyName: string, data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt data using Dapr crypto
+     */
+    decrypt(componentName: string, keyName: string, ciphertext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Start a new workflow
+     */
+    startWorkflow(workflowComponent: string, workflowName: string, options?: {
+        instanceID?: string;
+        input?: any;
+    }): Promise<{
+        instanceID: string;
+    }>;
+    /**
+     * Get workflow metadata
+     */
+    getWorkflow(workflowComponent: string): Promise<any>;
+    /**
+     * Terminate a workflow
+     */
+    terminateWorkflow(workflowComponent: string): Promise<void>;
+    /**
+     * Pause a workflow
+     */
+    pauseWorkflow(workflowComponent: string): Promise<void>;
+    /**
+     * Resume a workflow
+     */
+    resumeWorkflow(workflowComponent: string): Promise<void>;
+    /**
+     * Raise a workflow event
+     */
+    raiseWorkflowEvent(_workflowComponent: string, instanceID: string, eventName: string, eventData?: any): Promise<void>;
+    /**
+     * Purge workflow
+     */
+    purgeWorkflow(workflowComponent: string): Promise<void>;
+}
+export declare const daprService: DaprConnectionManager;
+export {};
+//# sourceMappingURL=dapr-manager.d.ts.map

package/dist/src/Managers/Dapr/error-handling.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Error handling utilities for the Dapr manager
+ */
+import type { DaprError } from "./types";
+export declare class DaprManagerError extends Error {
+    code: string;
+    details?: unknown;
+    constructor(code: string, message: string, details?: unknown);
+    toJSON(): DaprError;
+}
+export declare const createConnectionError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createTimeoutError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createStateError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createPubSubError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createBindingError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createSecretError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createConfigError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createInvokeError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createCryptoError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createLockError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createWorkflowError: (message: string, details?: unknown) => DaprManagerError;
+export declare const createValidationError: (message: string, details?: unknown) => DaprManagerError;
+/**
+ * Safely handle errors from Dapr client operations
+ * @param operation - Function to execute
+ * @param errorCreator - Function to create an error if the operation fails
+ */
+export declare const safeExecute: <T>(operation: () => Promise<T>, errorCreator: (message: string, details?: unknown) => DaprManagerError) => Promise<T>;
+//# sourceMappingURL=error-handling.d.ts.map

package/dist/src/Managers/Dapr/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Main Dapr manager that integrates all clients
+ */
+/** biome-ignore-all lint/correctness/noUnusedPrivateClassMembers: <> */
+import { DaprBindingClient } from "./clients/binding-client";
+import { DaprConfigClient } from "./clients/config-client";
+import { DaprCryptoClient } from "./clients/crypto-client";
+import { DaprInvokeClient } from "./clients/invoke-client";
+import { DaprLockClient } from "./clients/lock-client";
+import { DaprPubSubClient } from "./clients/pubsub-client";
+import { DaprSecretClient } from "./clients/secret-client";
+import { DaprStateClient } from "./clients/state-client";
+import { DaprWorkflowClient } from "./clients/workflow-client";
+import type { DaprConnectionOptions, HealthStatus } from "./types";
+export declare class DaprManager {
+    private connectionManager;
+    private logger;
+    private _state;
+    private _pubsub;
+    private _binding;
+    private _secret;
+    private _config;
+    private _invoke;
+    private _lock;
+    private _crypto;
+    private _workflow;
+    constructor(options?: DaprConnectionOptions);
+    /**
+     * Connect to Dapr sidecar
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from Dapr sidecar
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected to Dapr sidecar
+     */
+    isConnected(): boolean;
+    /**
+     * Get connection status
+     */
+    getConnectionStatus(): string;
+    /**
+     * Perform a health check on the Dapr sidecar
+     */
+    healthCheck(): Promise<HealthStatus>;
+    /**
+     * Get the Dapr client configuration
+     */
+    getClientConfig(): Record<string, any>;
+    /**
+     * Access the state management client
+     */
+    get state(): DaprStateClient;
+    /**
+     * Access the pubsub client
+     */
+    get pubsub(): DaprPubSubClient;
+    /**
+     * Access the binding client
+     */
+    get binding(): DaprBindingClient;
+    /**
+     * Access the secret client
+     */
+    get secret(): DaprSecretClient;
+    /**
+     * Access the configuration client
+     */
+    get config(): DaprConfigClient;
+    /**
+     * Access the service invocation client
+     */
+    get invoke(): DaprInvokeClient;
+    /**
+     * Access the distributed lock client
+     */
+    get lock(): DaprLockClient;
+    /**
+     * Access the cryptography client
+     */
+    get crypto(): DaprCryptoClient;
+    /**
+     * Access the workflow client
+     */
+    get workflow(): DaprWorkflowClient;
+}
+export declare const daprManager: DaprManager;
+export { DaprBindingClient } from "./clients/binding-client";
+export { DaprConfigClient } from "./clients/config-client";
+export { DaprCryptoClient } from "./clients/crypto-client";
+export { DaprInvokeClient } from "./clients/invoke-client";
+export { DaprLockClient } from "./clients/lock-client";
+export { DaprPubSubClient } from "./clients/pubsub-client";
+export { DaprSecretClient } from "./clients/secret-client";
+export { DaprStateClient } from "./clients/state-client";
+export { DaprWorkflowClient } from "./clients/workflow-client";
+export * from "./constants";
+export * from "./error-handling";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/Managers/Dapr/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Type definitions for the Dapr manager
+ */
+import type { CommunicationProtocolEnum } from "@dapr/dapr";
+export declare enum LockStatus {
+    Success = 0,
+    LockDoesNotExist = 1,
+    LockBelongsToOthers = 2,
+    InternalError = 3
+}
+export type DaprConnectionOptions = {
+    daprHost?: string;
+    daprPort?: string;
+    communicationProtocol?: CommunicationProtocolEnum;
+    maxBodySizeMb?: number;
+    daprApiToken?: string;
+    logger?: DaprLogger;
+};
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type DaprLogger = {
+    debug: (message: string, ...meta: unknown[]) => void;
+    info: (message: string, ...meta: unknown[]) => void;
+    warn: (message: string, ...meta: unknown[]) => void;
+    error: (message: string, ...meta: unknown[]) => void;
+};
+export type StateItem<T = unknown> = {
+    key: string;
+    value: T;
+    etag?: string;
+    metadata?: Record<string, string>;
+};
+export type StateSaveOptions = {
+    concurrency?: "first-write" | "last-write";
+    consistency?: "eventual" | "strong";
+    metadata?: Record<string, string>;
+};
+export type StateOperation<T = unknown> = {
+    operation: "upsert" | "delete";
+    request: {
+        key: string;
+        value?: T;
+        etag?: string;
+        metadata?: Record<string, string>;
+    };
+};
+export type PublishOptions = {
+    contentType?: string;
+    metadata?: Record<string, string>;
+};
+export type BulkPublishMessage<T = unknown> = {
+    entryId: string;
+    contentType?: string;
+    event: T;
+    metadata?: Record<string, string>;
+};
+export type BulkPublishResponse = {
+    failedEntries: Array<{
+        entryId: string;
+        error: string;
+    }>;
+};
+export type InvokeOptions = {
+    headers?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    timeout?: number;
+};
+export type BindingOptions = {
+    metadata?: Record<string, string>;
+};
+export type SecretOptions = {
+    metadata?: Record<string, string>;
+};
+export type ConfigItem = {
+    key: string;
+    value: string;
+    version: string;
+    metadata: Record<string, string>;
+};
+export type ConfigResponse = {
+    items: Record<string, ConfigItem>;
+};
+export type ConfigSubscriptionCallback = (data: ConfigResponse) => Promise<void> | void;
+export type ConfigSubscription = {
+    stop: () => void;
+};
+export type CryptoOptions = {
+    componentName: string;
+    keyName?: string;
+    keyWrapAlgorithm?: string;
+};
+export type LockOptions = {
+    expiryInSeconds: number;
+};
+export type LockResponse = {
+    success: boolean;
+};
+export type UnlockResponse = {
+    status: LockStatus;
+};
+export type WorkflowOptions = {
+    instanceId?: string;
+    workflowComponent?: string;
+};
+export type WorkflowInstance = {
+    instanceId: string;
+    workflowName: string;
+    createdAt: Date;
+    lastUpdatedAt: Date;
+    runtimeStatus: string;
+    properties: Record<string, string>;
+};
+export type HealthStatus = {
+    status: string;
+    version: string;
+};
+export type DaprError = {
+    code: string;
+    message: string;
+    details?: unknown;
+};
+//# sourceMappingURL=types.d.ts.map