@extrimian/agent 0.12.0-1 → 0.12.0-11

package/dist/models/transports/websocket-transport.d.ts

@@ -1,30 +1,30 @@
-import { Socket as ServerSocket } from 'socket.io';
-import { Socket as ClientSocket } from 'socket.io-client';
-import { Agent } from '../../agent';
-import { ILiteEvent, LiteEvent } from '../../utils/lite-event';
-import { DID } from '../did';
-import { ConnectableTransport } from './connectable-transport';
-import { MessageArrivedEventArg, TransportSendRequest } from './transport';
-type GenericSocket = ServerSocket | ClientSocket;
-export declare abstract class WebsocketTransport extends ConnectableTransport {
-    protected readonly wsDidDocumentId: string;
-    protected agent: Agent;
-    protected readonly onMessageArrived: LiteEvent<MessageArrivedEventArg>;
-    protected readonly connectedSockets: Map<string, GenericSocket>;
-    constructor(wsDidDocumentId?: string);
-    get messageArrived(): ILiteEvent<MessageArrivedEventArg>;
-    dispose(params?: {
-        did: DID;
-    }): Promise<void>;
-    initialize(params: {
-        agent: Agent;
-    }): Promise<void>;
-    abstract send(params: TransportSendRequest): Promise<void> | void;
-    transportSupportedByTarget(params: {
-        targetDID: DID;
-    }): Promise<boolean>;
-    listenToSocket(socket: GenericSocket, params?: {
-        did: DID;
-    }): void;
-}
-export {};
+import { Socket as ServerSocket } from 'socket.io';
+import { Socket as ClientSocket } from 'socket.io-client';
+import { Agent } from '../../agent';
+import { ILiteEvent, LiteEvent } from '../../utils/lite-event';
+import { DID } from '../did';
+import { ConnectableTransport } from './connectable-transport';
+import { MessageArrivedEventArg, TransportSendRequest } from './transport';
+type GenericSocket = ServerSocket | ClientSocket;
+export declare abstract class WebsocketTransport extends ConnectableTransport {
+    protected readonly wsDidDocumentId: string;
+    protected agent: Agent;
+    protected readonly onMessageArrived: LiteEvent<MessageArrivedEventArg>;
+    protected readonly connectedSockets: Map<string, GenericSocket>;
+    constructor(wsDidDocumentId?: string);
+    get messageArrived(): ILiteEvent<MessageArrivedEventArg>;
+    dispose(params?: {
+        did: DID;
+    }): Promise<void>;
+    initialize(params: {
+        agent: Agent;
+    }): Promise<void>;
+    abstract send(params: TransportSendRequest): Promise<void> | void;
+    transportSupportedByTarget(params: {
+        targetDID: DID;
+    }): Promise<boolean>;
+    listenToSocket(socket: GenericSocket, params?: {
+        did: DID;
+    }): void;
+}
+export {};

package/dist/models/transports/websocket-transport.js

@@ -1,85 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebsocketTransport = void 0;
-const did_core_1 = require("@extrimian/did-core");
-const lite_event_1 = require("../../utils/lite-event");
-const did_1 = require("../did");
-const connectable_transport_1 = require("./connectable-transport");
-class WebsocketTransport extends connectable_transport_1.ConnectableTransport {
-    constructor(wsDidDocumentId = 'MessagingWebSocket') {
-        super();
-        this.wsDidDocumentId = wsDidDocumentId;
-        this.onMessageArrived = new lite_event_1.LiteEvent();
-        this.connectedSockets = new Map();
-    }
-    get messageArrived() {
-        return this.onMessageArrived.expose();
-    }
-    async dispose(params) {
-        if (params === null || params === void 0 ? void 0 : params.did) {
-            const socket = this.connectedSockets.get(params.did.value);
-            if (socket) {
-                socket.disconnect();
-            }
-            this.connectedSockets.delete(params.did.value);
-            return;
-        }
-        else {
-            for (const socket of this.connectedSockets.values()) {
-                socket.disconnect();
-            }
-        }
-    }
-    async initialize(params) {
-        this.agent = params.agent;
-        this.onMessageArrived.on(async (data) => {
-            await this.handleMessage(data, this);
-        });
-    }
-    async transportSupportedByTarget(params) {
-        const connectedClient = this.connectedSockets.get(params.targetDID.value);
-        if (connectedClient)
-            return true;
-        const resolver = this.agent.resolver;
-        const targetDidDocument = await resolver.resolve(params.targetDID);
-        try {
-            const websocketUrl = did_core_1.DIDDocumentUtils.getServiceUrl(targetDidDocument, this.wsDidDocumentId)[0];
-            return !!websocketUrl;
-        }
-        catch {
-            return false;
-        }
-    }
-    listenToSocket(socket, params) {
-        socket.on('message', (data) => {
-            var _a, _b;
-            const existingSocket = this.connectedSockets.get(data.did);
-            if (!existingSocket) {
-                this.connectedSockets.set(data.did, socket);
-            }
-            this.onMessageArrived.trigger({
-                data: ((_a = data.message) === null || _a === void 0 ? void 0 : _a.message)
-                    ? JSON.parse(data.message.message)
-                    : data.message,
-                from: did_1.DID.from(data.did),
-                context: {
-                    messageManagerCompatible: !!((_b = data.message) === null || _b === void 0 ? void 0 : _b.message),
-                },
-            });
-        });
-        socket.on('connect', () => {
-            this.handleConnect({ did: params === null || params === void 0 ? void 0 : params.did });
-        });
-        socket.on('disconnect', () => {
-            const socketsByDid = Array.from(this.connectedSockets.entries());
-            socketsByDid.forEach(([did, socket]) => {
-                if (socket.disconnected) {
-                    this.handleDisconnect({ did: did_1.DID.from(did) });
-                    this.connectedSockets.delete(did);
-                }
-            });
-        });
-    }
-}
-exports.WebsocketTransport = WebsocketTransport;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketTransport = void 0;
+const did_core_1 = require("@extrimian/did-core");
+const lite_event_1 = require("../../utils/lite-event");
+const did_1 = require("../did");
+const connectable_transport_1 = require("./connectable-transport");
+class WebsocketTransport extends connectable_transport_1.ConnectableTransport {
+    constructor(wsDidDocumentId = 'MessagingWebSocket') {
+        super();
+        this.wsDidDocumentId = wsDidDocumentId;
+        this.onMessageArrived = new lite_event_1.LiteEvent();
+        this.connectedSockets = new Map();
+    }
+    get messageArrived() {
+        return this.onMessageArrived.expose();
+    }
+    async dispose(params) {
+        if (params === null || params === void 0 ? void 0 : params.did) {
+            const socket = this.connectedSockets.get(params.did.value);
+            if (socket) {
+                socket.disconnect();
+            }
+            this.connectedSockets.delete(params.did.value);
+            return;
+        }
+        else {
+            for (const socket of this.connectedSockets.values()) {
+                socket.disconnect();
+            }
+        }
+    }
+    async initialize(params) {
+        this.agent = params.agent;
+        this.onMessageArrived.on(async (data) => {
+            await this.handleMessage(data, this);
+        });
+    }
+    async transportSupportedByTarget(params) {
+        const connectedClient = this.connectedSockets.get(params.targetDID.value);
+        if (connectedClient)
+            return true;
+        const resolver = this.agent.resolver;
+        const targetDidDocument = await resolver.resolve(params.targetDID);
+        try {
+            const websocketUrl = did_core_1.DIDDocumentUtils.getServiceUrl(targetDidDocument, this.wsDidDocumentId)[0];
+            return !!websocketUrl;
+        }
+        catch {
+            return false;
+        }
+    }
+    listenToSocket(socket, params) {
+        socket.on('message', (data) => {
+            var _a, _b;
+            const existingSocket = this.connectedSockets.get(data.did);
+            if (!existingSocket) {
+                this.connectedSockets.set(data.did, socket);
+            }
+            this.onMessageArrived.trigger({
+                data: ((_a = data.message) === null || _a === void 0 ? void 0 : _a.message)
+                    ? JSON.parse(data.message.message)
+                    : data.message,
+                from: did_1.DID.from(data.did),
+                context: {
+                    messageManagerCompatible: !!((_b = data.message) === null || _b === void 0 ? void 0 : _b.message),
+                },
+            });
+        });
+        socket.on('connect', () => {
+            this.handleConnect({ did: params === null || params === void 0 ? void 0 : params.did });
+        });
+        socket.on('disconnect', () => {
+            const socketsByDid = Array.from(this.connectedSockets.entries());
+            socketsByDid.forEach(([did, socket]) => {
+                if (socket.disconnected) {
+                    this.handleDisconnect({ did: did_1.DID.from(did) });
+                    this.connectedSockets.delete(did);
+                }
+            });
+        });
+    }
+}
+exports.WebsocketTransport = WebsocketTransport;
 //# sourceMappingURL=websocket-transport.js.map

package/dist/models/vc-storage.d.ts

@@ -1,8 +1,8 @@
-import { VerifiableCredential } from "@extrimian/vc-core";
-import { DID } from "./did";
-export interface IVCStorage {
-    getAllByDID(did: DID): any;
-    save(did: DID, vc: VerifiableCredential): any;
-    getById(credentialId: string): any;
-    remove(did: DID, credentialId: string): any;
-}
+import { VerifiableCredential } from "@extrimian/vc-core";
+import { DID } from "./did";
+export interface IVCStorage {
+    getAllByDID(did: DID): any;
+    save(did: DID, vc: VerifiableCredential): any;
+    getById(credentialId: string): any;
+    remove(did: DID, credentialId: string): any;
+}

package/dist/models/vc-storage.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=vc-storage.js.map

package/dist/plugins/iplugin.d.ts

@@ -1,17 +1,17 @@
-import { Agent } from "../agent";
-import { DID } from "../models/did";
-export interface IAgentPlugin {
-    canHandle(input: IAgentPluginMessage): Promise<boolean>;
-    handle(input: IAgentPluginMessage): Promise<IAgentPluginResponse>;
-    initialize(params: {
-        agent: Agent;
-    }): Promise<void>;
-}
-export interface IAgentPluginResponse {
-    to: DID;
-    message: any;
-}
-export interface IAgentPluginMessage {
-    message: any;
-    contextMessage?: any;
-}
+import { Agent } from "../agent";
+import { DID } from "../models/did";
+export interface IAgentPlugin {
+    canHandle(input: IAgentPluginMessage): Promise<boolean>;
+    handle(input: IAgentPluginMessage): Promise<IAgentPluginResponse>;
+    initialize(params: {
+        agent: Agent;
+    }): Promise<void>;
+}
+export interface IAgentPluginResponse {
+    to: DID;
+    message: any;
+}
+export interface IAgentPluginMessage {
+    message: any;
+    contextMessage?: any;
+}

package/dist/plugins/iplugin.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=iplugin.js.map

package/dist/plugins/istatus-list-plugin.d.ts

@@ -1,14 +1,14 @@
-import { VerifiableCredential } from "@extrimian/vc-core";
-import { Agent } from "../agent";
-import { DID } from "../models/did";
-export interface IStatusListAgentPlugin {
-    canHandle(input: IStatusListPluginMessage): Promise<boolean>;
-    handle(input: IStatusListPluginMessage): Promise<void>;
-    initialize(params: {
-        agent: Agent;
-    }): Promise<void>;
-}
-export interface IStatusListPluginMessage {
-    vc: VerifiableCredential;
-    issuerDID: DID;
-}
+import { VerifiableCredential } from "@extrimian/vc-core";
+import { Agent } from "../agent";
+import { DID } from "../models/did";
+export interface IStatusListAgentPlugin {
+    canHandle(input: IStatusListPluginMessage): Promise<boolean>;
+    handle(input: IStatusListPluginMessage): Promise<void>;
+    initialize(params: {
+        agent: Agent;
+    }): Promise<void>;
+}
+export interface IStatusListPluginMessage {
+    vc: VerifiableCredential;
+    issuerDID: DID;
+}

package/dist/plugins/istatus-list-plugin.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=istatus-list-plugin.js.map

package/dist/plugins/ivc-interceptor-plugin.d.ts

@@ -1,9 +1,9 @@
-import { Agent } from "../agent";
-/**
- * Interfaz para los plugins de interceptación del flujo de credenciales verificables (VC).
- */
-export interface AgentPluginBase {
-    initialize(params: {
-        agent: Agent;
-    }): Promise<void>;
-}
+import { Agent } from "../agent";
+/**
+ * Interfaz para los plugins de interceptación del flujo de credenciales verificables (VC).
+ */
+export interface AgentPluginBase {
+    initialize(params: {
+        agent: Agent;
+    }): Promise<void>;
+}

package/dist/plugins/ivc-interceptor-plugin.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=ivc-interceptor-plugin.js.map

package/dist/plugins/plugin-dispatcher.d.ts

@@ -1,6 +1,6 @@
-import { IAgentPlugin, IAgentPluginMessage, IAgentPluginResponse } from "./iplugin";
-export declare class PluginDispatcher {
-    private plugins;
-    constructor(plugins: IAgentPlugin[]);
-    dispatch(input: IAgentPluginMessage): Promise<IAgentPluginResponse>;
-}
+import { IAgentPlugin, IAgentPluginMessage, IAgentPluginResponse } from "./iplugin";
+export declare class PluginDispatcher {
+    private plugins;
+    constructor(plugins: IAgentPlugin[]);
+    dispatch(input: IAgentPluginMessage): Promise<IAgentPluginResponse>;
+}

package/dist/plugins/plugin-dispatcher.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginDispatcher = void 0;
-const agent_plugin_not_found_1 = require("../exceptions/agent-plugin-not-found");
-class PluginDispatcher {
-    constructor(plugins) {
-        this.plugins = plugins;
-    }
-    async dispatch(input) {
-        for (const plugin of this.plugins) {
-            if (plugin.canHandle(input)) {
-                return await plugin.handle(input);
-            }
-        }
-        // Si llegamos aquí, es porque ningún plugin puede manejar la entrada
-        throw new agent_plugin_not_found_1.AgentPluginNotFound('No plugin was found that can handle the input');
-    }
-}
-exports.PluginDispatcher = PluginDispatcher;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginDispatcher = void 0;
+const agent_plugin_not_found_1 = require("../exceptions/agent-plugin-not-found");
+class PluginDispatcher {
+    constructor(plugins) {
+        this.plugins = plugins;
+    }
+    async dispatch(input) {
+        for (const plugin of this.plugins) {
+            if (plugin.canHandle(input)) {
+                return await plugin.handle(input);
+            }
+        }
+        // Si llegamos aquí, es porque ningún plugin puede manejar la entrada
+        throw new agent_plugin_not_found_1.AgentPluginNotFound('No plugin was found that can handle the input');
+    }
+}
+exports.PluginDispatcher = PluginDispatcher;
 //# sourceMappingURL=plugin-dispatcher.js.map

package/dist/transport/transport.d.ts

@@ -1,43 +1,43 @@
-import { Agent } from "../agent";
-import { DID } from "../models/did";
-import { ITransport, MessageArrivedEventArg } from "../models/transports/transport";
-export declare class AgentTransport {
-    private cacheStorage;
-    private readonly onMessageArrived;
-    get messageArrived(): import("../utils/lite-event").ILiteEvent<{
-        message: any;
-        transport: ITransport;
-        contextMessage: any;
-    }>;
-    private readonly onConnected;
-    get connected(): import("../utils/lite-event").ILiteEvent<{
-        did: DID;
-    }>;
-    private readonly onDisconnected;
-    get disconnected(): import("../utils/lite-event").ILiteEvent<{
-        did: DID;
-    }>;
-    transports: ITransport[];
-    agent: Agent;
-    constructor(params: {
-        agent: Agent;
-        transports?: ITransport[];
-    });
-    handleConnect(params?: {
-        did: DID;
-    }): Promise<void>;
-    handleDisconnect(params?: {
-        did: DID;
-    }): Promise<void>;
-    handleMessage(params: MessageArrivedEventArg, transport: ITransport): Promise<void>;
-    addTransports(transport: ITransport): void;
-    getTranportByMessageId(messageId: string): ITransport;
-    sendMessage(params: {
-        to: DID;
-        from?: DID;
-        message: any;
-        preferredTransport?: ITransport;
-        messageContext?: any;
-    }): Promise<void>;
-    private sendMessageUsingTransport;
-}
+import { Agent } from "../agent";
+import { DID } from "../models/did";
+import { ITransport, MessageArrivedEventArg } from "../models/transports/transport";
+export declare class AgentTransport {
+    private cacheStorage;
+    private readonly onMessageArrived;
+    get messageArrived(): import("../utils/lite-event").ILiteEvent<{
+        message: any;
+        transport: ITransport;
+        contextMessage: any;
+    }>;
+    private readonly onConnected;
+    get connected(): import("../utils/lite-event").ILiteEvent<{
+        did: DID;
+    }>;
+    private readonly onDisconnected;
+    get disconnected(): import("../utils/lite-event").ILiteEvent<{
+        did: DID;
+    }>;
+    transports: ITransport[];
+    agent: Agent;
+    constructor(params: {
+        agent: Agent;
+        transports?: ITransport[];
+    });
+    handleConnect(params?: {
+        did: DID;
+    }): Promise<void>;
+    handleDisconnect(params?: {
+        did: DID;
+    }): Promise<void>;
+    handleMessage(params: MessageArrivedEventArg, transport: ITransport): Promise<void>;
+    addTransports(transport: ITransport): void;
+    getTranportByMessageId(messageId: string): ITransport;
+    sendMessage(params: {
+        to: DID;
+        from?: DID;
+        message: any;
+        preferredTransport?: ITransport;
+        messageContext?: any;
+    }): Promise<void>;
+    private sendMessageUsingTransport;
+}