@extrimian/agent 0.12.0-1 → 0.12.0-11

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

@@ -1,184 +1,184 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inMemoryMessageStorage = exports.DWNAmiTransport = void 0;
-const did_core_1 = require("@extrimian/did-core");
-const dwn_client_ami_1 = require("@extrimian/dwn-client-ami");
-const lite_event_1 = require("../../utils/lite-event");
-const did_1 = require("../did");
-var AsyncLock = require('async-lock');
-var lock = new AsyncLock();
-class DWNAmiTransport {
-    get messageArrived() {
-        return this.onMessageArrived.expose();
-    }
-    constructor(params) {
-        this.onMessageArrived = new lite_event_1.LiteEvent();
-        this.dwnClientMap = new Map();
-        this.dwnPollMilliseconds = (params === null || params === void 0 ? void 0 : params.dwnPollMilliseconds) || 10000;
-    }
-    async transportSupportedByTarget(params) {
-        const targetDidDocument = await this.resolver.resolve(params.targetDID);
-        const dwnUrl = await did_core_1.DIDDocumentUtils.getServiceUrl(targetDidDocument, 'DecentralizedWebNode', 'nodes')[0];
-        return dwnUrl != null;
-    }
-    async dispose() {
-        // TODO: dispose
-    }
-    async processNewDID(did, initialzing = false) {
-        await lock.acquire("dwnClients", async () => {
-            if (this.dwnClientMap.get(did.value))
-                return;
-            if (!did.isLongDID()) {
-                const longDidDWNClient = Array.from(this.dwnClientMap.keys()).map(x => did_1.DID.from(x)).find(x => x.isLongDIDFor(did));
-                //Si ya existe un dwn transport polleando el long, se debe eliminar ese polleo y comenzar a pollear el short.
-                if (longDidDWNClient) {
-                    this.dwnClientMap.delete(longDidDWNClient.value);
-                }
-            }
-            else {
-                const shortDidDWNClient = Array.from(this.dwnClientMap.keys()).map(x => did_1.DID.from(x)).find(x => x.isShortDIDFor(did));
-                //Si ya existe un dwn transport polleando el short, no se debe pollear el DWN del longDID.
-                if (shortDidDWNClient)
-                    return;
-            }
-            const didDocument = await this.resolver.resolve(did);
-            let dwnClient;
-            try {
-                const dwnEndpoint = this.getServiceUrl(didDocument, 'DecentralizedWebNode', 'nodes');
-                if (!dwnEndpoint)
-                    return;
-                dwnClient = new dwn_client_ami_1.DWNAmiClient({
-                    did: did.value,
-                    storage: exports.inMemoryMessageStorage,
-                    inboxURL: dwnEndpoint[0],
-                });
-            }
-            catch (ex) {
-                console.error('An error occurred while polling for the DWN: DIDDocument has not a DWN service defined or it is not correct');
-                return;
-            }
-            this.dwnClientMap.set(did.value, dwnClient);
-            dwnClient.addSubscriber(async (messages) => {
-                messages.forEach((message) => {
-                    //Los mensajes de DIDComm en el DWN vienen con caracteres extraños y no permiten JSON.parsear el string si no se remueven esos caracteres.
-                    let messageManagerCompatible = false;
-                    if (message.data.message) {
-                        message.data = JSON.parse(message.data.message);
-                        messageManagerCompatible = true;
-                    }
-                    if (typeof message.data === 'string' &&
-                        message.data.indexOf('{') != 0 &&
-                        message.data.indexOf('"header":{"alg":"ECDH-1PU') > -1) {
-                        message.data = message.data.substring(message.data.indexOf('{'), message.data.lastIndexOf('}') + 1);
-                    }
-                    this.onMessageArrived.trigger({
-                        from: null,
-                        // from: messages[0].data?.message?.from,
-                        data: message.data,
-                        context: { ...message, messageManagerCompatible },
-                    });
-                });
-            });
-            if (!initialzing) {
-                this.startPollSpecificClient(did.value, dwnClient);
-            }
-        });
-    }
-    async initialize(params) {
-        this.agent = params.agent;
-        this.resolver = this.agent.resolver;
-        const dids = this.agent.identity.getDIDs();
-        for (let did of dids) {
-            await this.processNewDID(did_1.DID.from(did), true);
-        }
-        Array.from(this.dwnClientMap.keys()).forEach(did => {
-            this.startPollSpecificClient(did, this.dwnClientMap.get(did));
-        });
-        this.agent.identity.didCreated.on((args) => {
-            this.processNewDID(args.did);
-        });
-        this.onMessageArrived.on(async (data) => {
-            await this.agent.transport.handleMessage(data, this);
-        });
-    }
-    async send(params) {
-        var _a, _b, _c;
-        const targetDidDocument = await this.resolver.resolve(params.to);
-        const dwnUrl = await did_core_1.DIDDocumentUtils.getServiceUrl(targetDidDocument, 'DecentralizedWebNode', 'nodes')[0];
-        const msgParams = {
-            targetDID: params.to.value,
-            targetInboxURL: dwnUrl,
-            message: {
-                data: ((_a = params.context) === null || _a === void 0 ? void 0 : _a.messageManagerCompatible)
-                    ? { message: JSON.stringify(params.data) }
-                    : params.data,
-                descriptor: {
-                    method: undefined,
-                    dateCreated: new Date(),
-                    dataFormat: 'application/json',
-                },
-            },
-        };
-        if (!((_c = (_b = params.context) === null || _b === void 0 ? void 0 : _b.descriptor) === null || _c === void 0 ? void 0 : _c.method)) {
-            msgParams.message.descriptor.method = dwn_client_ami_1.ThreadMethod.Create;
-        }
-        else {
-            msgParams.message.descriptor.method = dwn_client_ami_1.ThreadMethod.Reply;
-            msgParams.message.descriptor.root =
-                params.context.descriptor.root || params.context.descriptor.objectId;
-            msgParams.message.descriptor.parent = params.context.descriptor.objectId;
-        }
-        await this.dwnClientMap
-            .get(this.agent.identity.getOperationalDID().value)
-            .sendMessage(msgParams)
-            .catch(console.error);
-    }
-    async startPollSpecificClient(did, dwnClient) {
-        try {
-            await dwnClient.pullNewMessageWait();
-        }
-        catch {
-            console.error("Error polling DWNClient for DID", did);
-        }
-        finally {
-            setTimeout(() => {
-                if (this.dwnClientMap.get(did)) {
-                    this.startPollSpecificClient(did, dwnClient);
-                }
-            }, this.dwnPollMilliseconds);
-        }
-    }
-    getServiceUrl(didDocument, serviceType, serviceEndpointMapKey) {
-        var _a;
-        try {
-            const service = (_a = didDocument.service) === null || _a === void 0 ? void 0 : _a.find((service) => service.type === serviceType);
-            if (!service)
-                return null;
-            if (typeof service.serviceEndpoint === 'object')
-                return service.serviceEndpoint[serviceEndpointMapKey];
-            return [service.serviceEndpoint];
-        }
-        catch (error) {
-            console.error(error);
-            throw Error(`Error finding ${serviceType} service in DID Document`);
-        }
-    }
-}
-exports.DWNAmiTransport = DWNAmiTransport;
-const messagesStorage = [];
-let lastPullDate;
-exports.inMemoryMessageStorage = {
-    async getMessages() {
-        return messagesStorage;
-    },
-    async getLastPullDate() {
-        return lastPullDate;
-    },
-    async updateLastPullDate(date) {
-        lastPullDate = date;
-    },
-    async saveMessages(messages) {
-        messagesStorage.push(...messages);
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inMemoryMessageStorage = exports.DWNAmiTransport = void 0;
+const did_core_1 = require("@extrimian/did-core");
+const dwn_client_ami_1 = require("@extrimian/dwn-client-ami");
+const lite_event_1 = require("../../utils/lite-event");
+const did_1 = require("../did");
+var AsyncLock = require('async-lock');
+var lock = new AsyncLock();
+class DWNAmiTransport {
+    get messageArrived() {
+        return this.onMessageArrived.expose();
+    }
+    constructor(params) {
+        this.onMessageArrived = new lite_event_1.LiteEvent();
+        this.dwnClientMap = new Map();
+        this.dwnPollMilliseconds = (params === null || params === void 0 ? void 0 : params.dwnPollMilliseconds) || 10000;
+    }
+    async transportSupportedByTarget(params) {
+        const targetDidDocument = await this.resolver.resolve(params.targetDID);
+        const dwnUrl = await did_core_1.DIDDocumentUtils.getServiceUrl(targetDidDocument, 'DecentralizedWebNode', 'nodes')[0];
+        return dwnUrl != null;
+    }
+    async dispose() {
+        // TODO: dispose
+    }
+    async processNewDID(did, initialzing = false) {
+        await lock.acquire("dwnClients", async () => {
+            if (this.dwnClientMap.get(did.value))
+                return;
+            if (!did.isLongDID()) {
+                const longDidDWNClient = Array.from(this.dwnClientMap.keys()).map(x => did_1.DID.from(x)).find(x => x.isLongDIDFor(did));
+                //Si ya existe un dwn transport polleando el long, se debe eliminar ese polleo y comenzar a pollear el short.
+                if (longDidDWNClient) {
+                    this.dwnClientMap.delete(longDidDWNClient.value);
+                }
+            }
+            else {
+                const shortDidDWNClient = Array.from(this.dwnClientMap.keys()).map(x => did_1.DID.from(x)).find(x => x.isShortDIDFor(did));
+                //Si ya existe un dwn transport polleando el short, no se debe pollear el DWN del longDID.
+                if (shortDidDWNClient)
+                    return;
+            }
+            const didDocument = await this.resolver.resolve(did);
+            let dwnClient;
+            try {
+                const dwnEndpoint = this.getServiceUrl(didDocument, 'DecentralizedWebNode', 'nodes');
+                if (!dwnEndpoint)
+                    return;
+                dwnClient = new dwn_client_ami_1.DWNAmiClient({
+                    did: did.value,
+                    storage: exports.inMemoryMessageStorage,
+                    inboxURL: dwnEndpoint[0],
+                });
+            }
+            catch (ex) {
+                console.error('An error occurred while polling for the DWN: DIDDocument has not a DWN service defined or it is not correct');
+                return;
+            }
+            this.dwnClientMap.set(did.value, dwnClient);
+            dwnClient.addSubscriber(async (messages) => {
+                messages.forEach((message) => {
+                    //Los mensajes de DIDComm en el DWN vienen con caracteres extraños y no permiten JSON.parsear el string si no se remueven esos caracteres.
+                    let messageManagerCompatible = false;
+                    if (message.data.message) {
+                        message.data = JSON.parse(message.data.message);
+                        messageManagerCompatible = true;
+                    }
+                    if (typeof message.data === 'string' &&
+                        message.data.indexOf('{') != 0 &&
+                        message.data.indexOf('"header":{"alg":"ECDH-1PU') > -1) {
+                        message.data = message.data.substring(message.data.indexOf('{'), message.data.lastIndexOf('}') + 1);
+                    }
+                    this.onMessageArrived.trigger({
+                        from: null,
+                        // from: messages[0].data?.message?.from,
+                        data: message.data,
+                        context: { ...message, messageManagerCompatible },
+                    });
+                });
+            });
+            if (!initialzing) {
+                this.startPollSpecificClient(did.value, dwnClient);
+            }
+        });
+    }
+    async initialize(params) {
+        this.agent = params.agent;
+        this.resolver = this.agent.resolver;
+        const dids = this.agent.identity.getDIDs();
+        for (let did of dids) {
+            await this.processNewDID(did_1.DID.from(did), true);
+        }
+        Array.from(this.dwnClientMap.keys()).forEach(did => {
+            this.startPollSpecificClient(did, this.dwnClientMap.get(did));
+        });
+        this.agent.identity.didCreated.on((args) => {
+            this.processNewDID(args.did);
+        });
+        this.onMessageArrived.on(async (data) => {
+            await this.agent.transport.handleMessage(data, this);
+        });
+    }
+    async send(params) {
+        var _a, _b, _c;
+        const targetDidDocument = await this.resolver.resolve(params.to);
+        const dwnUrl = await did_core_1.DIDDocumentUtils.getServiceUrl(targetDidDocument, 'DecentralizedWebNode', 'nodes')[0];
+        const msgParams = {
+            targetDID: params.to.value,
+            targetInboxURL: dwnUrl,
+            message: {
+                data: ((_a = params.context) === null || _a === void 0 ? void 0 : _a.messageManagerCompatible)
+                    ? { message: JSON.stringify(params.data) }
+                    : params.data,
+                descriptor: {
+                    method: undefined,
+                    dateCreated: new Date(),
+                    dataFormat: 'application/json',
+                },
+            },
+        };
+        if (!((_c = (_b = params.context) === null || _b === void 0 ? void 0 : _b.descriptor) === null || _c === void 0 ? void 0 : _c.method)) {
+            msgParams.message.descriptor.method = dwn_client_ami_1.ThreadMethod.Create;
+        }
+        else {
+            msgParams.message.descriptor.method = dwn_client_ami_1.ThreadMethod.Reply;
+            msgParams.message.descriptor.root =
+                params.context.descriptor.root || params.context.descriptor.objectId;
+            msgParams.message.descriptor.parent = params.context.descriptor.objectId;
+        }
+        await this.dwnClientMap
+            .get(this.agent.identity.getOperationalDID().value)
+            .sendMessage(msgParams)
+            .catch(console.error);
+    }
+    async startPollSpecificClient(did, dwnClient) {
+        try {
+            await dwnClient.pullNewMessageWait();
+        }
+        catch {
+            console.error("Error polling DWNClient for DID", did);
+        }
+        finally {
+            setTimeout(() => {
+                if (this.dwnClientMap.get(did)) {
+                    this.startPollSpecificClient(did, dwnClient);
+                }
+            }, this.dwnPollMilliseconds);
+        }
+    }
+    getServiceUrl(didDocument, serviceType, serviceEndpointMapKey) {
+        var _a;
+        try {
+            const service = (_a = didDocument.service) === null || _a === void 0 ? void 0 : _a.find((service) => service.type === serviceType);
+            if (!service)
+                return null;
+            if (typeof service.serviceEndpoint === 'object')
+                return service.serviceEndpoint[serviceEndpointMapKey];
+            return [service.serviceEndpoint];
+        }
+        catch (error) {
+            console.error(error);
+            throw Error(`Error finding ${serviceType} service in DID Document`);
+        }
+    }
+}
+exports.DWNAmiTransport = DWNAmiTransport;
+const messagesStorage = [];
+let lastPullDate;
+exports.inMemoryMessageStorage = {
+    async getMessages() {
+        return messagesStorage;
+    },
+    async getLastPullDate() {
+        return lastPullDate;
+    },
+    async updateLastPullDate(date) {
+        lastPullDate = date;
+    },
+    async saveMessages(messages) {
+        messagesStorage.push(...messages);
+    },
+};
 //# sourceMappingURL=ami-transport.js.map

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

@@ -1,25 +1,25 @@
-import { Agent } from '../../agent';
-import { ILiteEvent, LiteEvent } from '../../utils/lite-event';
-import { DID } from '../did';
-import { ITransport, MessageArrivedEventArg } from './transport';
-export declare abstract class ConnectableTransport implements ITransport {
-    protected agent: Agent;
-    protected readonly onMessageArrived: LiteEvent<MessageArrivedEventArg>;
-    protected handleConnect(params?: {
-        did: DID;
-    }): void;
-    protected handleDisconnect(params: {
-        did: DID;
-    }): void;
-    initialize(params: {
-        agent: Agent;
-    }): Promise<void>;
-    get messageArrived(): ILiteEvent<MessageArrivedEventArg>;
-    abstract send(params: {
-        data: any;
-        context?: any;
-    }): Promise<void> | void;
-    protected handleMessage(params: MessageArrivedEventArg, transport: ITransport): Promise<void>;
-    abstract transportSupportedByTarget(params: {}): Promise<boolean>;
-    abstract dispose(): Promise<void>;
-}
+import { Agent } from '../../agent';
+import { ILiteEvent, LiteEvent } from '../../utils/lite-event';
+import { DID } from '../did';
+import { ITransport, MessageArrivedEventArg } from './transport';
+export declare abstract class ConnectableTransport implements ITransport {
+    protected agent: Agent;
+    protected readonly onMessageArrived: LiteEvent<MessageArrivedEventArg>;
+    protected handleConnect(params?: {
+        did: DID;
+    }): void;
+    protected handleDisconnect(params: {
+        did: DID;
+    }): void;
+    initialize(params: {
+        agent: Agent;
+    }): Promise<void>;
+    get messageArrived(): ILiteEvent<MessageArrivedEventArg>;
+    abstract send(params: {
+        data: any;
+        context?: any;
+    }): Promise<void> | void;
+    protected handleMessage(params: MessageArrivedEventArg, transport: ITransport): Promise<void>;
+    abstract transportSupportedByTarget(params: {}): Promise<boolean>;
+    abstract dispose(): Promise<void>;
+}

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

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectableTransport = void 0;
-const lite_event_1 = require("../../utils/lite-event");
-class ConnectableTransport {
-    constructor() {
-        this.onMessageArrived = new lite_event_1.LiteEvent();
-    }
-    handleConnect(params) {
-        this.agent.transport.handleConnect({ did: params.did });
-    }
-    handleDisconnect(params) {
-        this.agent.transport.handleDisconnect({ did: params.did });
-    }
-    async initialize(params) {
-        this.agent = params.agent;
-    }
-    get messageArrived() {
-        return this.onMessageArrived.expose();
-    }
-    handleMessage(params, transport) {
-        return this.agent.transport.handleMessage(params, transport);
-    }
-}
-exports.ConnectableTransport = ConnectableTransport;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectableTransport = void 0;
+const lite_event_1 = require("../../utils/lite-event");
+class ConnectableTransport {
+    constructor() {
+        this.onMessageArrived = new lite_event_1.LiteEvent();
+    }
+    handleConnect(params) {
+        this.agent.transport.handleConnect({ did: params.did });
+    }
+    handleDisconnect(params) {
+        this.agent.transport.handleDisconnect({ did: params.did });
+    }
+    async initialize(params) {
+        this.agent = params.agent;
+    }
+    get messageArrived() {
+        return this.onMessageArrived.expose();
+    }
+    handleMessage(params, transport) {
+        return this.agent.transport.handleMessage(params, transport);
+    }
+}
+exports.ConnectableTransport = ConnectableTransport;
 //# sourceMappingURL=connectable-transport.js.map

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

@@ -1,32 +1,32 @@
-import { DIDDocument } from '@extrimian/did-core';
-import { DWNClient, MessageStorage } from '@extrimian/dwn-client';
-import { Agent } from '../../agent';
-import { ILiteEvent } from '../../utils/lite-event';
-import { DID } from '../did';
-import { IMessagingTransport } from './messaging-transport';
-import { MessageArrivedEventArg, TransportSendRequest } from './transport';
-export declare class DWNTransport implements IMessagingTransport {
-    private readonly onMessageArrived;
-    get messageArrived(): ILiteEvent<MessageArrivedEventArg>;
-    dwnClientMap: Map<string, DWNClient>;
-    agent: Agent;
-    private resolver;
-    dwnPollMilliseconds: number;
-    storage?: MessageStorage;
-    constructor(params?: {
-        dwnPollMilliseconds?: number;
-        storage?: MessageStorage;
-    });
-    transportSupportedByTarget(params: {
-        targetDID: DID;
-    }): Promise<boolean>;
-    dispose(): Promise<void>;
-    processNewDID(did: DID, initialzing?: boolean): Promise<void>;
-    initialize(params: {
-        agent: Agent;
-    }): Promise<void>;
-    send(params: TransportSendRequest): Promise<void>;
-    startPollSpecificClient(did: string, dwnClient: DWNClient): Promise<void>;
-    getServiceUrl(didDocument: DIDDocument, serviceType: string, serviceEndpointMapKey?: string): string[];
-}
-export declare const inMemoryMessageStorage: MessageStorage;
+import { DIDDocument } from '@extrimian/did-core';
+import { DWNClient, MessageStorage } from '@extrimian/dwn-client';
+import { Agent } from '../../agent';
+import { ILiteEvent } from '../../utils/lite-event';
+import { DID } from '../did';
+import { IMessagingTransport } from './messaging-transport';
+import { MessageArrivedEventArg, TransportSendRequest } from './transport';
+export declare class DWNTransport implements IMessagingTransport {
+    private readonly onMessageArrived;
+    get messageArrived(): ILiteEvent<MessageArrivedEventArg>;
+    dwnClientMap: Map<string, DWNClient>;
+    agent: Agent;
+    private resolver;
+    dwnPollMilliseconds: number;
+    storage?: MessageStorage;
+    constructor(params?: {
+        dwnPollMilliseconds?: number;
+        storage?: MessageStorage;
+    });
+    transportSupportedByTarget(params: {
+        targetDID: DID;
+    }): Promise<boolean>;
+    dispose(): Promise<void>;
+    processNewDID(did: DID, initialzing?: boolean): Promise<void>;
+    initialize(params: {
+        agent: Agent;
+    }): Promise<void>;
+    send(params: TransportSendRequest): Promise<void>;
+    startPollSpecificClient(did: string, dwnClient: DWNClient): Promise<void>;
+    getServiceUrl(didDocument: DIDDocument, serviceType: string, serviceEndpointMapKey?: string): string[];
+}
+export declare const inMemoryMessageStorage: MessageStorage;