@msssystems/mss-link-sdk 0.1.11 → 0.2.1

package/dist/client/mss-link-browser-client.js

@@ -1,256 +0,0 @@
-import { normalizeProductApiBaseUrl } from './api-base-url';
-import { normalizeLocalCryptoError } from './decryption-errors';
-import { checkLocalCryptoHealth } from './local-crypto-health';
-import { buildMediaMessageMetadataPayload, extractMediaAssetIds, serializeMediaMessageMetadata, } from './media-message-metadata';
-import { mapLocalSdkMessage } from './message.mapper';
-import { buildDecryptedDriveFileMetadata, buildDecryptedDriveFolderMetadata, buildEncryptedDriveFileMetadata, buildEncryptedDriveFolderMetadata, normalizeDriveFileMetadataInput, normalizeDriveFolderMetadataInput, normalizeEncryptedDriveFileMetadataInput, normalizeEncryptedDriveFolderMetadataInput, } from './storage-metadata-crypto';
-import { createDriveWrappedItemKeyForRecipient } from './drive-key-wrapping';
-import { WasmCallQueue } from './wasm-call-queue';
-const DEFAULT_DEVICE_ID = 1;
-const DEFAULT_REGISTRATION_ID = 1;
-const DEFAULT_SIGNED_PREKEY_ID = 1;
-const DEFAULT_ONE_TIME_PREKEY_COUNT = 10;
-const DEFAULT_MIN_ONE_TIME_PREKEYS = 5;
-const DEFAULT_REPLENISH_ONE_TIME_PREKEYS = 10;
-export class MssLinkBrowserClient {
-    userId;
-    apiBaseUrl;
-    deviceId;
-    registrationId;
-    signedPrekeyId;
-    initialOneTimePrekeyCount;
-    minOneTimePrekeys;
-    replenishOneTimePrekeys;
-    queue = new WasmCallQueue();
-    wasmClient = null;
-    wasmModulePromise = null;
-    accessToken;
-    constructor(options) {
-        this.userId = options.userId;
-        this.apiBaseUrl = normalizeProductApiBaseUrl(options.apiBaseUrl);
-        this.accessToken = options.accessToken ?? null;
-        this.deviceId = options.deviceId ?? DEFAULT_DEVICE_ID;
-        this.registrationId =
-            options.registrationId ?? DEFAULT_REGISTRATION_ID;
-        this.signedPrekeyId =
-            options.signedPrekeyId ?? DEFAULT_SIGNED_PREKEY_ID;
-        this.initialOneTimePrekeyCount =
-            options.initialOneTimePrekeyCount ??
-                DEFAULT_ONE_TIME_PREKEY_COUNT;
-        this.minOneTimePrekeys =
-            options.minOneTimePrekeys ?? DEFAULT_MIN_ONE_TIME_PREKEYS;
-        this.replenishOneTimePrekeys =
-            options.replenishOneTimePrekeys ??
-                DEFAULT_REPLENISH_ONE_TIME_PREKEYS;
-    }
-    setAccessToken(accessToken) {
-        this.accessToken = accessToken;
-        this.wasmClient?.setAccessToken(accessToken);
-    }
-    async ensureReady() {
-        try {
-            await this.runWithClient(async (client) => {
-                await client.ensureDeviceRegistered(this.registrationId, this.signedPrekeyId, this.initialOneTimePrekeyCount);
-                await client.replenishOneTimePreKeys(this.minOneTimePrekeys, this.replenishOneTimePrekeys);
-            });
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async getLocalCryptoHealth() {
-        return checkLocalCryptoHealth(() => this.ensureReady());
-    }
-    async sendMessage(params) {
-        try {
-            await this.ensureReady();
-            return this.runWithClient((client) => client.sendMessage(params.chatId, params.targetUserId, params.text, params.kind ?? 'TEXT'));
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async sendMediaMessage(params) {
-        try {
-            await this.ensureReady();
-            const payload = buildMediaMessageMetadataPayload(params.attachments, params.caption);
-            const metadataJson = serializeMediaMessageMetadata(payload);
-            const mediaAssetIds = extractMediaAssetIds(params.attachments);
-            return this.runWithClient((client) => client.sendMediaMessage(params.chatId, params.targetUserId, metadataJson, mediaAssetIds));
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async encryptMediaBlob(input) {
-        try {
-            const plaintext = new Uint8Array(await input.blob.arrayBuffer());
-            const encrypted = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.encryptMediaBytes(plaintext);
-            });
-            const encryptedBytes = new Uint8Array(encrypted.ciphertext);
-            return {
-                encryptedBlob: new Blob([encryptedBytes], {
-                    type: 'application/octet-stream',
-                }),
-                encryption: {
-                    schema: 'mss.link.media-encryption.v1',
-                    algorithm: 'AES-256-GCM',
-                    keyId: input.assetId,
-                    nonce: encrypted.nonce,
-                    wrappedKey: encrypted.key,
-                },
-                attachment: {
-                    assetId: input.assetId,
-                    mimeType: input.mimeType,
-                    size: input.size,
-                    ...(input.originalName ? { originalName: input.originalName } : {}),
-                    ...(input.uploadedAt ? { uploadedAt: input.uploadedAt } : {}),
-                    encryption: {
-                        schema: 'mss.link.media-encryption.v1',
-                        algorithm: 'AES-256-GCM',
-                        keyId: input.assetId,
-                        nonce: encrypted.nonce,
-                        wrappedKey: encrypted.key,
-                    },
-                },
-            };
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async decryptMediaBlob(input) {
-        const encryption = input.metadata.encryption;
-        if (!encryption) {
-            return {
-                blob: input.encryptedBlob,
-                mimeType: input.metadata.mimeType,
-                ...(input.metadata.originalName
-                    ? { fileName: input.metadata.originalName }
-                    : {}),
-            };
-        }
-        try {
-            const ciphertext = new Uint8Array(await input.encryptedBlob.arrayBuffer());
-            const plaintext = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.decryptMediaBytes(ciphertext, encryption.wrappedKey, encryption.nonce);
-            });
-            return {
-                blob: new Blob([new Uint8Array(plaintext)], {
-                    type: input.metadata.mimeType,
-                }),
-                mimeType: input.metadata.mimeType,
-                ...(input.metadata.originalName
-                    ? { fileName: input.metadata.originalName }
-                    : {}),
-            };
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async encryptDriveFolderMetadata(input) {
-        try {
-            const metadata = normalizeDriveFolderMetadataInput(input);
-            const encryptedName = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.encryptStorageMetadata(metadata.name);
-            });
-            return buildEncryptedDriveFolderMetadata(encryptedName);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async decryptDriveFolderMetadata(input) {
-        try {
-            const metadata = normalizeEncryptedDriveFolderMetadataInput(input);
-            const name = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return module.decryptStorageMetadata(metadata.encryptedName);
-            });
-            return buildDecryptedDriveFolderMetadata(name);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async encryptDriveFileMetadata(input) {
-        try {
-            const metadata = normalizeDriveFileMetadataInput(input);
-            const [encryptedName, encryptedMimeType] = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return [
-                    module.encryptStorageMetadata(metadata.name),
-                    module.encryptStorageMetadata(metadata.mimeType),
-                ];
-            });
-            return buildEncryptedDriveFileMetadata(encryptedName, encryptedMimeType);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async decryptDriveFileMetadata(input) {
-        try {
-            const metadata = normalizeEncryptedDriveFileMetadataInput(input);
-            const [name, mimeType] = await this.queue.run(async () => {
-                const module = await this.loadWasmModule();
-                return [
-                    module.decryptStorageMetadata(metadata.encryptedName),
-                    module.decryptStorageMetadata(metadata.encryptedMimeType),
-                ];
-            });
-            return buildDecryptedDriveFileMetadata(name, mimeType);
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    createDriveWrappedItemKeyForRecipient(input) {
-        return createDriveWrappedItemKeyForRecipient(input);
-    }
-    async syncMessages() {
-        try {
-            await this.runWithClient((client) => client.syncMessages());
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    async getLocalMessages(chatId) {
-        try {
-            const rawMessages = await this.runWithClient((client) => client.getLocalMessages(chatId));
-            return rawMessages.map((message) => mapLocalSdkMessage(message));
-        }
-        catch (error) {
-            throw normalizeLocalCryptoError(error);
-        }
-    }
-    reset() {
-        this.wasmClient?.free();
-        this.wasmClient = null;
-        this.wasmModulePromise = null;
-    }
-    async runWithClient(callback) {
-        return this.queue.run(async () => callback(await this.getClient()));
-    }
-    async getClient() {
-        if (typeof window === 'undefined') {
-            throw new Error('MSS Link browser client is available only in browser context.');
-        }
-        if (!this.wasmClient) {
-            const sdkModule = await this.loadWasmModule();
-            this.wasmClient = new sdkModule.WasmMssClient(this.userId, this.deviceId, this.apiBaseUrl);
-            this.wasmClient.setAccessToken(this.accessToken);
-        }
-        return this.wasmClient;
-    }
-    loadWasmModule() {
-        this.wasmModulePromise ??= import('@msssystems/mss-crypto-wasm').then((module) => module);
-        return this.wasmModulePromise;
-    }
-}