@omicron-x/daedalus-sdk 1.0.0

package/README.md

@@ -0,0 +1,63 @@
+# Daedalus Node.js Worker SDK
+
+Node.js/TypeScript SDK for interacting with the Daedalus Orchestrator.
+
+## Installation
+
+```bash
+cd sdk/nodejs-sdk
+npm install
+```
+
+## How to Build
+
+You can compile the SDK using Nx from the project root:
+
+```bash
+nx run server:build-sdk-nodejs
+```
+
+Or manually within the `sdk/nodejs-sdk` folder:
+
+```bash
+npm run build
+```
+
+## Examples
+
+### Simple Worker
+
+To run the simple worker example:
+
+```bash
+nx run server:run-nodejs-simple-worker
+```
+
+Or manually:
+
+```bash
+cd sdk/nodejs-sdk
+npx ts-node examples/simple-worker/index.ts
+```
+
+### Assert Resources
+
+To run the assert resources example:
+
+```bash
+nx run server:run-nodejs-assert-resources
+```
+
+Demonstrates how to upsert a tenant, exchange, queue, and binding using the `assertTenant`, `assertExchange`, `assertQueue`, and `assertBinding` methods.
+
+```bash
+cd sdk/nodejs-sdk
+npm run example:assert-resources
+```
+
+Or manually:
+
+```bash
+cd sdk/nodejs-sdk
+npx ts-node examples/assert-resources/index.ts
+```

package/dist/examples/simple-worker/index.d.ts

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

package/dist/examples/simple-worker/index.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../src/index");
+const si = __importStar(require("systeminformation"));
+async function getSystemInfo() {
+    try {
+        const cpu = await si.currentLoad();
+        const mem = await si.mem();
+        const disk = await si.fsSize();
+        const info = {
+            "CPU": cpu.currentLoad.toFixed(2),
+            "Memory": ((mem.active / mem.total) * 100).toFixed(2),
+            "Disk": disk[0].use.toFixed(2),
+            "OS": String(process.platform),
+            "Hostname": await si.osInfo().then(info => String(info.hostname))
+        };
+        return info;
+    }
+    catch (err) {
+        console.error('❌ Error gathering system info:', err);
+        return {
+            "Error": "Failed to gather system info"
+        };
+    }
+}
+async function main() {
+    const daedalusSDK = new index_1.DaedalusSDK({
+        uri: 'http://localhost:4000',
+        username: 'admin',
+        password: 'admin'
+    });
+    await daedalusSDK.connect();
+    await daedalusSDK.createWorker({
+        workerName: 'Simple Node.js Worker 2',
+        intervalMs: 10000,
+        information: getSystemInfo,
+        capacityPolicies: [
+            {
+                maxQueueMessages: 10,
+                currentQueueMessages: 0,
+                claimWorkFilter: {}
+            }
+        ],
+        onMessage: async (message, ack) => {
+            console.log('👷 Processing message:', message);
+            console.log('📝 Content:', message);
+            // Simulate processing
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Acknowledge the message after processing
+            console.log('✅ Message processed, sending ACK...');
+            await ack();
+        }
+    });
+    console.log('✅ Worker is running. Press Ctrl+C to stop.');
+}
+main().catch(err => {
+    console.error('💥 Fatal error:', err);
+});

package/dist/src/index.d.ts

@@ -0,0 +1,73 @@
+export interface ClaimWorkFilter {
+    tenantCodes?: string[];
+    excludeTenantCodes?: string[];
+    tenantPatterns?: string[];
+    excludeTenantPatterns?: string[];
+    vNamespaces?: string[];
+    excludeVNamespaces?: string[];
+    vNamespacePatterns?: string[];
+    excludeVNamespacePatterns?: string[];
+    queueCodes?: string[];
+    excludeQueueCodes?: string[];
+    queuePatterns?: string[];
+    excludeQueuePatterns?: string[];
+}
+export interface ClaimWorkCapacityPolicy {
+    maxQueueMessages: number;
+    currentQueueMessages: number;
+    claimWorkFilter?: ClaimWorkFilter;
+}
+export interface QueueMessage {
+    id: string;
+    messageId: string;
+    content: string;
+    contentType: string;
+    headers: Record<string, string>;
+    queueId: string;
+    priority: number;
+    handler: string;
+    parameters: Record<string, string>;
+    vNamespace: string;
+    createdAt: string;
+}
+export interface QueueMessageLease {
+    id: string;
+    queueMessageId: string;
+    workerId: string;
+    leaseUntil: string;
+}
+export interface ClaimedMessage {
+    message: QueueMessage;
+    lease: QueueMessageLease;
+    tenantCode: string;
+}
+export interface AckCallback {
+    (): Promise<void>;
+}
+export interface WorkerOptions {
+    workerName: string;
+    information?: Record<string, string> | (() => Promise<Record<string, string>> | Record<string, string>);
+    capacityPolicies: ClaimWorkCapacityPolicy[];
+    intervalMs?: number;
+    onMessage?: (claimedMessage: ClaimedMessage, ack: AckCallback) => Promise<void> | void;
+}
+export declare class DaedalusSDK {
+    private config;
+    private jobWorkerClient;
+    private authClient;
+    private token;
+    private jobWorkerProtoPath;
+    private authProtoPath;
+    constructor(config: {
+        uri: string;
+        username: string;
+        password: string;
+    });
+    private loadProto;
+    connect(): Promise<void>;
+    private login;
+    disconnect(): Promise<void>;
+    private getMetadata;
+    ackMessage(leaseID: string, tenantCode: string): Promise<void>;
+    createWorker(options: WorkerOptions): Promise<void>;
+}

package/dist/src/index.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaedalusSDK = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const path = __importStar(require("path"));
+const crypto = require('crypto');
+class DaedalusSDK {
+    config;
+    jobWorkerClient;
+    authClient;
+    token = null;
+    jobWorkerProtoPath;
+    authProtoPath;
+    constructor(config) {
+        this.config = config;
+        this.jobWorkerProtoPath = path.resolve(__dirname, '../../../server/internal/infrastructure/server/grpc/proto/definitions/jobworker.proto');
+        this.authProtoPath = path.resolve(__dirname, '../../../server/internal/infrastructure/server/grpc/proto/definitions/auth.proto');
+    }
+    loadProto(protoPath) {
+        const packageDefinition = protoLoader.loadSync(protoPath, {
+            keepCase: true,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true
+        });
+        return grpc.loadPackageDefinition(packageDefinition);
+    }
+    async connect() {
+        const target = this.config.uri.replace('http://', '').replace('https://', '');
+        // Load Auth Proto and create client
+        const authProtoDescriptor = this.loadProto(this.authProtoPath);
+        this.authClient = new authProtoDescriptor.auth.AuthService(target, grpc.credentials.createInsecure());
+        // Perform Initial Login
+        await this.login();
+        // Load JobWorker Proto and create client
+        const jobWorkerProtoDescriptor = this.loadProto(this.jobWorkerProtoPath);
+        this.jobWorkerClient = new jobWorkerProtoDescriptor.jobworker.JobWorkerService(target, grpc.credentials.createInsecure());
+    }
+    async login() {
+        console.log(`🔐 Logging in as ${this.config.username}...`);
+        try {
+            const loginResponse = await new Promise((resolve, reject) => {
+                this.authClient.Login({
+                    usernameOrEmail: this.config.username,
+                    password: this.config.password
+                }, (err, response) => {
+                    if (err)
+                        return reject(err);
+                    resolve(response);
+                });
+            });
+            this.token = loginResponse.token;
+            console.log('✅ Logged in successfully');
+        }
+        catch (err) {
+            console.error('❌ Login failed:', err.message);
+            throw err;
+        }
+    }
+    async disconnect() {
+        if (this.jobWorkerClient) {
+            this.jobWorkerClient.close();
+        }
+        if (this.authClient) {
+            this.authClient.close();
+        }
+    }
+    getMetadata() {
+        const metadata = new grpc.Metadata();
+        if (this.token) {
+            metadata.add('Authorization', `Bearer ${this.token}`);
+        }
+        return metadata;
+    }
+    async ackMessage(leaseID, tenantCode) {
+        return new Promise((resolve, reject) => {
+            this.jobWorkerClient.AckMessage({ leaseID, tenantCode }, this.getMetadata(), (err, response) => {
+                if (err) {
+                    console.error('❌ Failed to ack message:', err.message);
+                    return reject(err);
+                }
+                if (!response.success) {
+                    console.error('❌ Ack message failed:', response.message);
+                    return reject(new Error(response.message));
+                }
+                console.log('✅ Message acknowledged successfully');
+                resolve();
+            });
+        });
+    }
+    async createWorker(options) {
+        const { workerName, information, capacityPolicies, intervalMs = 10000, // 10 seconds
+        onMessage } = options;
+        const workerId = `${crypto.randomUUID()}-${Date.now()}`;
+        const run = async () => {
+            try {
+                if (!this.token) {
+                    console.log('⚠️ Not authenticated. Attempting to log in...');
+                    await this.login();
+                }
+                // Create bidirectional stream
+                const call = this.jobWorkerClient.ClaimWork(this.getMetadata());
+                console.log(`🔌 Opening bidirectional stream for worker ${workerId}...`);
+                // Handle incoming messages from server
+                call.on('data', async (streamMessage) => {
+                    if (streamMessage.ack) {
+                        console.log('✅ Connected to server:', streamMessage.ack.knowledge);
+                    }
+                    else if (streamMessage.claimedMessage) {
+                        const claimed = streamMessage.claimedMessage;
+                        console.log(`📬 Received message: ${claimed.message.ID} from tenant ${claimed.tenantCode}`);
+                        if (onMessage) {
+                            try {
+                                const claimedMessage = {
+                                    message: {
+                                        id: claimed.message.ID,
+                                        messageId: claimed.message.MessageID,
+                                        content: claimed.message.Content,
+                                        contentType: claimed.message.ContentType,
+                                        headers: claimed.message.Headers || {},
+                                        queueId: claimed.message.QueueID,
+                                        priority: claimed.message.Priority,
+                                        handler: claimed.message.Handler,
+                                        parameters: claimed.message.Parameters || {},
+                                        vNamespace: claimed.message.VNamespace,
+                                        createdAt: claimed.message.CreatedAt
+                                    },
+                                    lease: {
+                                        id: claimed.lease.ID,
+                                        queueMessageId: claimed.lease.QueueMessageID,
+                                        workerId: claimed.lease.WorkerID,
+                                        leaseUntil: claimed.lease.LeaseUntil
+                                    },
+                                    tenantCode: claimed.tenantCode
+                                };
+                                const ackCallback = async () => {
+                                    await this.ackMessage(claimed.lease.ID, claimed.tenantCode);
+                                };
+                                await onMessage(claimedMessage, ackCallback);
+                            }
+                            catch (handlerError) {
+                                console.error('❌ Error in onMessage handler:', handlerError.message);
+                            }
+                        }
+                    }
+                });
+                call.on('error', (err) => {
+                    if (err.code === 16) { // UNAUTHENTICATED
+                        console.warn('🔄 Session expired (Error 16). Refreshing token...');
+                        this.token = null;
+                    }
+                    else if (err.code === 1) { // CANCELLED
+                        console.log('🚫 Stream cancelled');
+                    }
+                    else {
+                        console.error('❌ Stream error:', err.message);
+                    }
+                });
+                call.on('end', () => {
+                    console.log('🔌 Stream ended, will reconnect...');
+                });
+                // Function to send claim request
+                const sendClaimRequest = async () => {
+                    let currentInformation = {};
+                    if (typeof information === 'function') {
+                        currentInformation = await information();
+                    }
+                    else if (information) {
+                        currentInformation = information;
+                    }
+                    const request = {
+                        workerID: workerId,
+                        workerName: workerName,
+                        information: currentInformation,
+                        capacityPolicies: capacityPolicies
+                    };
+                    call.write(request, (err) => {
+                        if (err) {
+                            console.error('❌ Error sending claim request:', err.message);
+                        }
+                    });
+                };
+                // Send initial claim request
+                await sendClaimRequest();
+                // Send claim requests periodically
+                const claimInterval = setInterval(async () => {
+                    await sendClaimRequest();
+                }, intervalMs);
+                // Wait for stream to end
+                await new Promise((resolve) => {
+                    call.on('end', () => {
+                        clearInterval(claimInterval);
+                        resolve();
+                    });
+                    call.on('error', () => {
+                        clearInterval(claimInterval);
+                        resolve();
+                    });
+                });
+            }
+            catch (err) {
+                console.error('❌ Unexpected error in worker loop:', err.message);
+            }
+            // Reconnect after delay
+            console.log(`⏳ Reconnecting in ${intervalMs}ms...`);
+            setTimeout(run, intervalMs);
+        };
+        console.log(`🚀 Starting worker ${workerName} (${workerId}) with ${intervalMs}ms interval...`);
+        run();
+    }
+}
+exports.DaedalusSDK = DaedalusSDK;

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@omicron-x/daedalus-sdk",
+    "version": "1.0.0",
+    "description": "Daedalus Orchestrator Node.js Worker",
+    "main": "dist/src/index.js",
+    "types": "dist/src/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "license": "Apache-2.0",
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsc",
+        "example:simple-worker": "ts-node examples/simple-worker/index.ts",
+        "example:assert-resources": "ts-node examples/assert-resources/index.ts"
+    },
+    "dependencies": {
+        "@grpc/grpc-js": "^1.9.0",
+        "@grpc/proto-loader": "^0.7.8",
+        "systeminformation": "^5.21.0"
+    },
+    "devDependencies": {
+        "typescript": "^5.0.0",
+        "ts-node": "^10.9.0",
+        "@types/node": "^20.0.0"
+    }
+}