@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.41

package/dist/o-core/src/core/o-core.js

@@ -0,0 +1,463 @@
+import { NodeState } from './interfaces/state.enum.js';
+import { oAddress } from '../router/o-address.js';
+import { NodeType } from './interfaces/node-type.enum.js';
+import { oDependency } from './o-dependency.js';
+import { oError } from '../error/o-error.js';
+import { oObject } from './o-object.js';
+import { oMetrics } from './lib/o-metrics.js';
+import { oHierarchyManager } from './lib/o-hierarchy.manager.js';
+import { oRequestManager } from './lib/o-request.manager.js';
+import { oRequest } from '../connection/o-request.js';
+import { ResponseBuilder } from '../response/response-builder.js';
+export class oCore extends oObject {
+    constructor(config) {
+        super((config.name ? `:${config.name}` : '') + ':' + config.address.toString());
+        this.config = config;
+        this.state = NodeState.STOPPED;
+        this.errors = [];
+        this.metrics = new oMetrics();
+        this.requestManager = new oRequestManager();
+        this.address = config.address || new oAddress('o://node');
+        this.hierarchyManager = new oHierarchyManager({
+            leaders: this.config.leader ? [this.config.leader] : [],
+            parents: this.config.parent ? [this.config.parent] : [],
+        });
+    }
+    get isLeader() {
+        return this.config.type === NodeType.LEADER;
+    }
+    get leader() {
+        return this.isLeader ? this.address : this.config?.leader || null;
+    }
+    async useStream(address, data, options) {
+        return this.use(address, {
+            ...data,
+            params: {
+                ...data.params,
+                _isStreaming: true,
+            },
+        }, {
+            ...options,
+            isStream: true,
+        });
+    }
+    async useDirect(address, data) {
+        return this.use(address, data, { noRouting: true });
+    }
+    /**
+     * Sends a request to a remote node in the O-Lane network using the specified address and optional data payload.
+     *
+     * This method handles the complete communication flow:
+     * 1. Validates the target address format
+     * 2. Resolves the routing path through the network
+     * 3. Establishes a connection to the target node
+     * 4. Sends the request payload and waits for response
+     * 5. Handles errors and throws them as oError instances
+     *
+     * @param address - The target node address in O-Lane format (must start with 'o://')
+     * @param data - Optional request data containing method, parameters, and request ID
+     * @param data.method - The method name to invoke on the target node
+     * @param data.params - Key-value pairs of parameters to pass to the method
+     * @param data.id - Unique identifier for the request (for tracking purposes)
+     * @returns Promise that resolves to an oResponse containing the result from the target node
+     * @throws {Error} When the address is invalid (doesn't pass validation)
+     * @throws {oError} When the target node returns an error response
+     *
+     * @example
+     * ```typescript
+     * // Basic usage - call a method on a remote node
+     * const response = await node.use(
+     *   new oAddress('o://calculator/add'),
+     *   {
+     *     method: 'add',
+     *     params: { a: 5, b: 3 },
+     *     id: 'calc-001'
+     *   }
+     * );
+     * console.log(response.result); // { result: 8 }
+     *
+     * // Minimal usage - just specify the address
+     * const response = await node.use(
+     *   new oAddress('o://status/health')
+     * );
+     * console.log(response.result); // { status: 'healthy' }
+     *
+     * // Error handling
+     * try {
+     *   const response = await node.use(
+     *     new oAddress('o://calculator/divide'),
+     *     { method: 'divide', params: { a: 10, b: 0 } }
+     *   );
+     * } catch (error) {
+     *   if (error instanceof oError) {
+     *     console.error(`Node error ${error.code}: ${error.message}`);
+     *   } else {
+     *     console.error('Invalid address or connection error:', error.message);
+     *   }
+     * }
+     * ```
+     */
+    async use(address, data, options) {
+        this.validateRunning();
+        if (!address.validate()) {
+            throw new Error('Invalid address');
+        }
+        this.logger.debug('Using address: ', address.toString());
+        // check for static match
+        if (address.toStaticAddress().equals(this.address.toStaticAddress())) {
+            return this.useSelf(data);
+        }
+        // if no routing is requested, use the address as is
+        if (options?.noRouting) {
+            this.logger.debug('No routing requested, using address as is', address.toString());
+        }
+        const { nextHopAddress, targetAddress } = options?.noRouting
+            ? { nextHopAddress: address, targetAddress: address }
+            : await this.router.translate(address, this);
+        if (nextHopAddress.toStaticAddress().equals(this.address.toStaticAddress())) {
+            return this.useSelf(data);
+        }
+        const connection = await this.connect({
+            nextHopAddress: nextHopAddress,
+            address: targetAddress,
+            callerAddress: this.address,
+            readTimeoutMs: options?.readTimeoutMs,
+            drainTimeoutMs: options?.drainTimeoutMs,
+            isStream: options?.isStream,
+            abortSignal: options?.abortSignal,
+        });
+        if (options?.isStream) {
+            connection.onChunk((response) => {
+                options.onChunk?.(response);
+            });
+        }
+        // communicate the payload to the target node
+        const response = await connection.send({
+            address: targetAddress?.toString() || '',
+            payload: data || {},
+            id: data?.id,
+        });
+        // we handle streaming response differently
+        if (options?.isStream) {
+            return response;
+        }
+        // if there is an error, throw it to continue to bubble up
+        this.handleResponseError(response);
+        return response;
+    }
+    /**
+     * Helper method to handle response errors
+     * @param response The response to check for errors
+     * @throws oError if the response contains an error
+     */
+    handleResponseError(response) {
+        if (response.result.error) {
+            this.logger.error('response.result.error', JSON.stringify(response.result.error, null, 2));
+            throw oError.fromJSON(response.result.error);
+        }
+    }
+    /**
+     * Helper method to validate node is running
+     * @throws Error if node is not running
+     */
+    validateRunning() {
+        if (!this.isRunning) {
+            this.logger.error('Node is not running', this.state);
+            throw new Error('Node is not running');
+        }
+    }
+    async useSelf(data) {
+        this.validateRunning();
+        // let's call our own tool
+        this.logger.debug('Calling ourselves, skipping...', data);
+        const request = new oRequest({
+            method: data?.method,
+            params: {
+                _connectionId: 0,
+                _requestMethod: data?.method,
+                ...data?.params,
+            },
+            id: 0,
+        });
+        // Use ResponseBuilder with automatic error handling and metrics tracking
+        const responseBuilder = ResponseBuilder.create().withMetrics(this.metrics);
+        try {
+            const result = await this.execute(request);
+            return await responseBuilder.build(request, result, null);
+        }
+        catch (error) {
+            this.logger.error('Error executing tool [self]: ', error);
+            return await responseBuilder.buildError(request, error);
+        }
+    }
+    async useChild(childAddress, data, options) {
+        this.validateRunning();
+        if (!childAddress.transports) {
+            const child = this.hierarchyManager.getChild(childAddress);
+            if (!child) {
+                this.logger.warn('Child address has no transports, this might break!');
+            }
+            else {
+                this.logger.debug('Setting transports for child: ', child.transports.map((t) => t.toString()));
+                childAddress.setTransports(child?.transports || []);
+            }
+        }
+        const connection = await this.connect({
+            nextHopAddress: childAddress,
+            address: childAddress,
+            callerAddress: this.address,
+            isStream: options?.isStream,
+        });
+        if (options?.isStream) {
+            connection.onChunk((response) => {
+                options.onChunk?.(response);
+            });
+        }
+        // communicate the payload to the target node
+        const response = await connection.send({
+            address: childAddress?.toString() || '',
+            payload: data || {},
+            id: data?.id,
+        });
+        // if there is an error, throw it to continue to bubble up
+        this.handleResponseError(response);
+        return response;
+    }
+    // hierarchy
+    addChildNode(node) {
+        this.hierarchyManager.addChild(node.address);
+    }
+    removeChildNode(node) {
+        this.hierarchyManager.removeChild(node.address);
+    }
+    /**
+     * Emit a notification event
+     */
+    notify(event) {
+        if (this.notificationManager) {
+            this.notificationManager.emit(event);
+        }
+    }
+    /**
+     * Subscribe to notification events
+     */
+    onNotification(eventType, handler, filter) {
+        if (!this.notificationManager) {
+            throw new Error('Notification manager not initialized');
+        }
+        return this.notificationManager.on(eventType, handler, filter);
+    }
+    // initialize
+    async initialize() {
+        // Create and initialize notification manager
+        this.notificationManager = this.createNotificationManager();
+        await this.notificationManager.initialize();
+    }
+    get isRunning() {
+        return (this.state === NodeState.RUNNING ||
+            this.state === NodeState.STOPPING ||
+            this.state === NodeState.STARTING);
+    }
+    async hookStartFinished() { }
+    /**
+     * Starts the node by transitioning through initialization and registration phases.
+     *
+     * This method performs the following operations in sequence:
+     * 1. Validates that the node is in STOPPED state
+     * 2. Sets state to STARTING
+     * 3. Calls initialize() to set up the node's core components
+     * 4. Attempts registration with the network (registration errors are logged but don't fail startup)
+     * 5. Sets state to RUNNING on success
+     *
+     * @throws {Error} If the node is not in STOPPED state or initialization fails
+     * @returns {Promise<void>} Resolves when the node is successfully started and running
+     *
+     * @example
+     * ```typescript
+     * const node = new oNode(config);
+     * try {
+     *   await node.start();
+     *   console.log('Node is now running');
+     * } catch (error) {
+     *   console.error('Failed to start node:', error);
+     * }
+     * ```
+     *
+     * @remarks
+     * - If the node is already running or starting, the method will log a warning and return early
+     * - Registration failures are logged but do not prevent the node from starting
+     * - On any initialization error, the node state is set to ERROR and teardown() is called
+     * - The node must be in STOPPED state before calling this method
+     */
+    async start() {
+        if (this.state !== NodeState.STOPPED) {
+            this.logger.warn('Node is not stopped, skipping start');
+            return;
+        }
+        this.state = NodeState.STARTING;
+        try {
+            await this.initialize();
+            await this.register().catch((error) => {
+                this.logger.error('Failed to register node', error);
+            });
+            await this.hookStartFinished();
+            this.state = NodeState.RUNNING;
+            // Start optional heartbeat to monitor if enabled
+            if (process.env.MONITOR_ENABLED === 'true' &&
+                process.env.MONITOR_ADDRESS) {
+                this.startHeartbeat();
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to start node', error);
+            this.errors.push(error);
+            this.state = NodeState.ERROR;
+            await this.teardown();
+        }
+    }
+    /**
+     * Stops the node by performing cleanup and transitioning to a stopped state.
+     *
+     * This method performs the following operations in sequence:
+     * 1. Sets state to STOPPING
+     * 2. Calls teardown() to clean up node resources and connections
+     * 3. Sets state to STOPPED on successful completion
+     *
+     * @throws {Error} If teardown operations fail, the node state will be set to ERROR
+     * @returns {Promise<void>} Resolves when the node is successfully stopped
+     *
+     * @example
+     * ```typescript
+     * const node = new oNode(config);
+     * await node.start();
+     *
+     * // Later, when shutting down
+     * try {
+     *   await node.stop();
+     *   console.log('Node stopped successfully');
+     * } catch (error) {
+     *   console.error('Failed to stop node:', error);
+     * }
+     * ```
+     *
+     * @remarks
+     * - This method can be called from any node state
+     * - If teardown fails, errors are logged and the node state is set to ERROR
+     * - All cleanup operations are performed through the teardown() method
+     * - The method will attempt to stop gracefully even if the node is in an error state
+     */
+    async stop() {
+        this.logger.debug('Stop node called...');
+        if (this.state !== NodeState.RUNNING) {
+            this.logger.warn('Node is not running, skipping stop');
+            return;
+        }
+        this.state = NodeState.STOPPING;
+        // Stop heartbeat if running
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+        try {
+            await this.teardown();
+            this.state = NodeState.STOPPED;
+            this.logger.debug('Node stopped!');
+        }
+        catch (error) {
+            this.errors.push(error);
+            this.state = NodeState.ERROR;
+            this.logger.error('Node failed to stop', error);
+        }
+    }
+    async teardown() {
+        this.logger.debug('Tearing down node...');
+        this.state = NodeState.STOPPING;
+        for (const child of this.hierarchyManager.children) {
+            this.logger.debug('Stopping child: ' + child.toString());
+            await this.useChild(child, {
+                method: 'stop',
+                params: {},
+            }).catch((error) => {
+                if (error.message === 'No data received') {
+                    // ignore
+                }
+                else {
+                    this.logger.error('Potential error stopping child', error);
+                }
+            });
+            this.logger.debug('Child stopped: ' + child.toString());
+        }
+        this.hierarchyManager.clear();
+        // Teardown notification manager
+        if (this.notificationManager) {
+            await this.notificationManager.teardown();
+        }
+    }
+    get dependencies() {
+        return this.config.dependencies?.map((d) => new oDependency(d)) || [];
+    }
+    /**
+     * Start sending periodic heartbeats to the monitor node
+     * This is optional and only runs if MONITOR_ENABLED=true and MONITOR_ADDRESS is set
+     */
+    startHeartbeat() {
+        const interval = parseInt(process.env.MONITOR_HEARTBEAT_INTERVAL || '30000', 10);
+        const monitorAddress = new oAddress(process.env.MONITOR_ADDRESS || 'o://monitor');
+        this.logger.debug(`Starting heartbeat to ${monitorAddress.toString()} every ${interval}ms`);
+        this.heartbeatInterval = setInterval(async () => {
+            try {
+                const metrics = {
+                    successCount: this.metrics.successCount,
+                    errorCount: this.metrics.errorCount,
+                    activeRequests: this.requestManager.activeRequests.length,
+                    state: this.state,
+                };
+                // Add stream count if available (oNode instances have this method)
+                if (typeof this.getStreamCount === 'function') {
+                    metrics.streamCount = this.getStreamCount();
+                }
+                await this.use(monitorAddress, {
+                    method: 'record_heartbeat',
+                    params: {
+                        address: this.address.toString(),
+                        timestamp: Date.now(),
+                        metrics,
+                    },
+                });
+            }
+            catch (error) {
+                // Monitor unavailable, fail silently
+                this.logger.debug('Heartbeat failed (monitor unavailable):', error);
+            }
+        }, interval);
+    }
+    get methods() {
+        return this.config.methods || {};
+    }
+    get description() {
+        return this.config.description || '';
+    }
+    get staticAddress() {
+        return this.config.address;
+    }
+    get type() {
+        return this.config.type || NodeType.UNKNOWN;
+    }
+    get transports() {
+        return [];
+    }
+    get parent() {
+        return this.config.parent || null;
+    }
+    get parentTransports() {
+        return this.parent?.transports || [];
+    }
+    async whoami() {
+        return {
+            address: this.address.toString(),
+            type: this.type,
+            description: this.description,
+            methods: this.methods,
+        };
+    }
+}

package/dist/o-core/src/core/o-dependency.d.ts

@@ -0,0 +1,9 @@
+import { oDependency as oDependencyType } from '@olane/o-protocol';
+export declare class oDependency implements oDependencyType {
+    address: string;
+    version?: string;
+    constructor(config: oDependencyType);
+    toJSON(): oDependencyType;
+    toString(): string;
+}
+//# sourceMappingURL=o-dependency.d.ts.map

package/dist/o-core/src/core/o-dependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-dependency.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/core/o-dependency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEnE,qBAAa,WAAY,YAAW,eAAe;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;gBAEL,MAAM,EAAE,eAAe;IAKnC,MAAM,IAAI,eAAe;IAOzB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/o-core/src/core/o-dependency.js

@@ -0,0 +1,15 @@
+export class oDependency {
+    constructor(config) {
+        this.address = config.address;
+        this.version = config.version;
+    }
+    toJSON() {
+        return {
+            address: this.address,
+            version: this.version,
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+}

package/dist/o-core/src/core/o-object.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from '../utils/logger.js';
+export declare class oObject {
+    logger: Logger;
+    constructor(name?: string);
+    static log(...args: any[]): void;
+}
+//# sourceMappingURL=o-object.d.ts.map

package/dist/o-core/src/core/o-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-object.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/core/o-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,qBAAa,OAAO;IACX,MAAM,EAAE,MAAM,CAAC;gBACV,IAAI,CAAC,EAAE,MAAM;IAIzB,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;CAI1B"}

package/dist/o-core/src/core/o-object.js

@@ -0,0 +1,10 @@
+import { Logger } from '../utils/logger.js';
+export class oObject {
+    constructor(name) {
+        this.logger = new Logger(this.constructor.name + (name ? `:${name}` : ''));
+    }
+    static log(...args) {
+        const l = new Logger(this.constructor.name);
+        l.debug(...args);
+    }
+}

package/dist/o-core/src/core/o-parameter.d.ts

@@ -0,0 +1,12 @@
+import { oParameter as oParameterType } from '@olane/o-protocol';
+export declare class oParameter implements oParameterType {
+    name: string;
+    type: string;
+    value: any;
+    description?: string;
+    required?: boolean;
+    constructor(config: oParameterType);
+    toJSON(): oParameterType;
+    toString(): string;
+}
+//# sourceMappingURL=o-parameter.d.ts.map

package/dist/o-core/src/core/o-parameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-parameter.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/core/o-parameter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEjE,qBAAa,UAAW,YAAW,cAAc;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,GAAG,CAAC;IACX,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;gBAEP,MAAM,EAAE,cAAc;IAQlC,MAAM,IAAI,cAAc;IAUxB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/o-core/src/core/o-parameter.js

@@ -0,0 +1,21 @@
+export class oParameter {
+    constructor(config) {
+        this.name = config.name;
+        this.type = config.type;
+        this.value = config.value;
+        this.description = config.description;
+        this.required = config.required;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            value: this.value,
+            description: this.description,
+            required: this.required,
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+}

package/dist/o-core/src/error/enums/codes.error.d.ts

@@ -0,0 +1,20 @@
+export declare enum oErrorCodes {
+    UNKNOWN = 1001,
+    NOT_FOUND = 1002,
+    NOT_IMPLEMENTED = 1003,
+    NOT_CONFIGURED = 1004,
+    NOT_AUTHORIZED = 1005,
+    MISSING_PARAMETERS = 1006,
+    INVALID_PARAMETERS = 1007,
+    INVALID_RESPONSE = 1008,
+    INVALID_REQUEST = 1009,
+    INVALID_STATE = 1010,
+    INVALID_ACTION = 1011,
+    INVALID_CREDENTIALS = 1012,
+    TRANSPORT_NOT_SUPPORTED = 1013,
+    FAILED_TO_DIAL_TARGET = 1014,
+    INVALID_CAPABILITY = 1015,
+    CONNECTION_LIMIT_REACHED = 1016,
+    TIMEOUT = 1017
+}
+//# sourceMappingURL=codes.error.d.ts.map

package/dist/o-core/src/error/enums/codes.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codes.error.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/error/enums/codes.error.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW;IACrB,OAAO,OAAO;IACd,SAAS,OAAO;IAChB,eAAe,OAAO;IACtB,cAAc,OAAO;IACrB,cAAc,OAAO;IACrB,kBAAkB,OAAO;IACzB,kBAAkB,OAAO;IACzB,gBAAgB,OAAO;IACvB,eAAe,OAAO;IACtB,aAAa,OAAO;IACpB,cAAc,OAAO;IACrB,mBAAmB,OAAO;IAC1B,uBAAuB,OAAO;IAC9B,qBAAqB,OAAO;IAC5B,kBAAkB,OAAO;IACzB,wBAAwB,OAAO;IAC/B,OAAO,OAAO;CACf"}

package/dist/o-core/src/error/enums/codes.error.js

@@ -0,0 +1,20 @@
+export var oErrorCodes;
+(function (oErrorCodes) {
+    oErrorCodes[oErrorCodes["UNKNOWN"] = 1001] = "UNKNOWN";
+    oErrorCodes[oErrorCodes["NOT_FOUND"] = 1002] = "NOT_FOUND";
+    oErrorCodes[oErrorCodes["NOT_IMPLEMENTED"] = 1003] = "NOT_IMPLEMENTED";
+    oErrorCodes[oErrorCodes["NOT_CONFIGURED"] = 1004] = "NOT_CONFIGURED";
+    oErrorCodes[oErrorCodes["NOT_AUTHORIZED"] = 1005] = "NOT_AUTHORIZED";
+    oErrorCodes[oErrorCodes["MISSING_PARAMETERS"] = 1006] = "MISSING_PARAMETERS";
+    oErrorCodes[oErrorCodes["INVALID_PARAMETERS"] = 1007] = "INVALID_PARAMETERS";
+    oErrorCodes[oErrorCodes["INVALID_RESPONSE"] = 1008] = "INVALID_RESPONSE";
+    oErrorCodes[oErrorCodes["INVALID_REQUEST"] = 1009] = "INVALID_REQUEST";
+    oErrorCodes[oErrorCodes["INVALID_STATE"] = 1010] = "INVALID_STATE";
+    oErrorCodes[oErrorCodes["INVALID_ACTION"] = 1011] = "INVALID_ACTION";
+    oErrorCodes[oErrorCodes["INVALID_CREDENTIALS"] = 1012] = "INVALID_CREDENTIALS";
+    oErrorCodes[oErrorCodes["TRANSPORT_NOT_SUPPORTED"] = 1013] = "TRANSPORT_NOT_SUPPORTED";
+    oErrorCodes[oErrorCodes["FAILED_TO_DIAL_TARGET"] = 1014] = "FAILED_TO_DIAL_TARGET";
+    oErrorCodes[oErrorCodes["INVALID_CAPABILITY"] = 1015] = "INVALID_CAPABILITY";
+    oErrorCodes[oErrorCodes["CONNECTION_LIMIT_REACHED"] = 1016] = "CONNECTION_LIMIT_REACHED";
+    oErrorCodes[oErrorCodes["TIMEOUT"] = 1017] = "TIMEOUT";
+})(oErrorCodes || (oErrorCodes = {}));

package/dist/o-core/src/error/index.d.ts

@@ -0,0 +1,3 @@
+export * from './o-error.js';
+export * from './enums/codes.error.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/o-core/src/error/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/error/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC"}

package/dist/o-core/src/error/index.js

@@ -0,0 +1,2 @@
+export * from './o-error.js';
+export * from './enums/codes.error.js';

package/dist/o-core/src/error/interfaces/o-error.interface.d.ts

@@ -0,0 +1,6 @@
+export interface oErrorInterface {
+    code: number;
+    message: string;
+    details?: any;
+}
+//# sourceMappingURL=o-error.interface.d.ts.map

package/dist/o-core/src/error/interfaces/o-error.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-error.interface.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/error/interfaces/o-error.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,CAAC;CACf"}

package/dist/o-core/src/error/interfaces/o-error.interface.js

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

package/dist/o-core/src/error/o-error.d.ts

@@ -0,0 +1,15 @@
+import { oErrorInterface } from './interfaces/o-error.interface.js';
+export declare class oError extends Error implements oErrorInterface {
+    code: number;
+    details?: any;
+    message: string;
+    constructor(code: number, message: string, details?: any);
+    toJSON(): {
+        code: number;
+        message: string;
+        details: any;
+    };
+    static fromJSON(json: any): oError;
+    toString(): string;
+}
+//# sourceMappingURL=o-error.d.ts.map

package/dist/o-core/src/error/o-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-error.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/error/o-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEpE,qBAAa,MAAO,SAAQ,KAAM,YAAW,eAAe;IAC1D,IAAI,EAAE,MAAM,CAAK;IACjB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,EAAE,MAAM,CAAM;gBAET,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG;IAOxD,MAAM;;;;;IAQN,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG;IAOzB,QAAQ;CAGT"}

package/dist/o-core/src/error/o-error.js

@@ -0,0 +1,27 @@
+import { oErrorCodes } from './enums/codes.error.js';
+export class oError extends Error {
+    constructor(code, message, details) {
+        super(message);
+        this.code = 0;
+        this.message = '';
+        this.code = code;
+        this.message = message;
+        this.details = details;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+            details: this.details,
+        };
+    }
+    static fromJSON(json) {
+        if (json?.code && json?.message) {
+            return new oError(json.code, json.message, json.details);
+        }
+        return new oError(oErrorCodes.UNKNOWN, json, json?.details);
+    }
+    toString() {
+        return `OLANE ERROR CODE: ${this.code}\nMESSAGE: ${this.message}\n-----\nDETAILS: ${this.details}`;
+    }
+}