@secrecy/lib 1.7.0-integration-mixed-feats.3 → 1.7.0-integration-trpc-client.1

package/dist/lib/utils/popup-tools.js

@@ -0,0 +1,180 @@
+/**
+ * TS Rewrite of https://github.com/enhancv/popup-tools
+ */
+const defaultOptions = {
+    width: 700,
+    height: 520,
+    menubar: 'no',
+    resizable: 'yes',
+    location: 'yes',
+    scrollbars: 'no',
+    centered: true,
+};
+let popupCount = 1;
+/**
+ * Return options converted to a string
+ *
+ * @param  {Object} options
+ * @return {String}
+ */
+function optionsToString(options) {
+    return Object.entries(options)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(',');
+}
+/**
+ * Get a unique name on each call
+ * @return {String}
+ */
+function defaultPopupName() {
+    popupCount += 1;
+    return `Popup ${popupCount}`;
+}
+/**
+ * Convert "centered: true" key into concrete left and top arguments
+ * Both can be overwritten
+ *
+ * @param  {Object} options
+ * @return {Object}
+ */
+function optionsResolveCentered(options) {
+    if (options.width === undefined || options.height === undefined) {
+        throw new Error('Should have width and height');
+    }
+    const result = { ...options };
+    const width = window.outerWidth - options.width;
+    const height = window.outerHeight - options.height;
+    if (options.centered === true) {
+        result.left = options.left ?? Math.round(window.screenX + width / 2);
+        result.top = options.top ?? Math.round(window.screenY + height / 2.5);
+        delete result.centered;
+    }
+    return result;
+}
+/**
+ * Create a form element, add hidden inputs for all the post data
+ * and post it into a newly opened popup
+ *
+ * @param  {String} url
+ * @param  {Object} postData
+ * @param  {String} name
+ * @param  {Object} options
+ * @return {Object}
+ */
+function openPopupWithPost(url, postData, name, options) {
+    const form = document.createElement('form');
+    let win = null;
+    form.setAttribute('method', 'post');
+    form.setAttribute('action', url);
+    form.setAttribute('target', name);
+    Object.keys(postData).forEach(function addFormItem(key) {
+        const input = document.createElement('input');
+        input.type = 'hidden';
+        input.name = key;
+        input.value = postData[key];
+        form.appendChild(input);
+    });
+    document.body.appendChild(form);
+    win = window.open('/', name, options);
+    win?.document.write('Loading...');
+    form.submit();
+    document.body.removeChild(form);
+    return win;
+}
+/**
+ * Open a popup using the first argument. Wait for it to close.
+ * Returns the window object
+ *
+ * @param  {Function}
+ * @param  {String}
+ * @param  {String}
+ * @param  {Object}
+ * @param  {Function}
+ * @return {Object}
+ */
+function popupExecute(execute, url, name, options, callback) {
+    const popupName = name ?? defaultPopupName();
+    const popupOptions = optionsResolveCentered(Object.assign({}, defaultOptions, options));
+    const popupCallback = callback ??
+        function noop() {
+            //
+        };
+    const optionsString = optionsToString(popupOptions);
+    const win = execute(url, popupName, optionsString);
+    let isMessageSent = false;
+    let interval;
+    function popupCallbackOnce(err, data) {
+        if (!isMessageSent) {
+            isMessageSent = true;
+            popupCallback(err, data);
+        }
+    }
+    function onMessage(message) {
+        const data = message !== undefined ? message.data : undefined;
+        if (data !== undefined && data.id === popupName) {
+            popupCallbackOnce(undefined, data.data);
+            window.removeEventListener('message', onMessage);
+            clearInterval(interval);
+        }
+    }
+    window.addEventListener('message', onMessage, false);
+    if (win !== null) {
+        interval = window.setInterval(function closePopupCallback() {
+            if (win === null || win.closed) {
+                setTimeout(function delayWindowClosing() {
+                    clearInterval(interval);
+                    popupCallbackOnce(new Error('Popup closed'));
+                }, 500);
+            }
+        }, 100);
+    }
+    else {
+        popupCallbackOnce(new Error('Popup blocked'));
+    }
+    return win;
+}
+/**
+ * Open a popup using the first argument.
+ * Wait for it to close and call the callback.
+ * Set the options string using the options object
+ * Returns the window object
+ *
+ * @param  {String} url
+ * @param  {String} name
+ * @param  {Object} options
+ * @param  {Function} callback
+ * @return {Object}
+ */
+export function popup(url, name, options, callback) {
+    return popupExecute(window.open, url, name, options, callback);
+}
+/**
+ * Open a popup using the first argument.
+ * Post the data into the open popup.
+ * Wait for it to close and call the callback.
+ * Set the options string using the options object
+ * Returns the window object
+ *
+ * @param  {String} url
+ * @param  {Object} postData
+ * @param  {String} name
+ * @param  {Object} options
+ * @param  {Function} callback
+ * @return {Object}
+ */
+export function popupWithPost(url, postData, name, options, callback) {
+    function openWithPostData(popupUrl, popupName, optionsString) {
+        return openPopupWithPost(popupUrl, postData, popupName, optionsString);
+    }
+    return popupExecute(openWithPostData, url, name, options, callback);
+}
+/**
+ * Return html that when executed, will trigger the popup to callback with a response
+ *
+ * @param  {Object}
+ * @return {String}
+ */
+export function popupResponse(id, data) {
+    const jsonData = JSON.stringify({ id, data });
+    return `<script>window.opener.postMessage(${jsonData}, "*");setTimeout(function() { window.close(); }, 50);</script>`;
+}

package/dist/lib/utils/promise.js

@@ -0,0 +1,20 @@
+export const promiseAllLimit = async (n, list) => {
+    const head = list.slice(0, n);
+    const tail = list.slice(n);
+    const result = [];
+    const execute = async (promise, i, runNext) => {
+        result[i] = await promise();
+        await runNext();
+    };
+    const runNext = async () => {
+        const i = list.length - tail.length;
+        const promise = tail.shift();
+        if (promise !== undefined) {
+            await execute(promise, i, runNext);
+        }
+    };
+    await Promise.all(head.map(async (promise, i) => {
+        await execute(promise, i, runNext);
+    }));
+    return result;
+};

package/dist/lib/utils/store-buddy.js

@@ -0,0 +1,60 @@
+/**
+ * Create persistent or temporary client-side storage with a portable,
+ * type-safe wrapper around the [Web Storage API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API).
+ * @param key The key used to access the stored value.
+ * @param [session] Save data in sessionStorage (`true`) or in localStorage
+ * (`false`). Default is `false`.
+ * @example
+ *
+ * ```ts
+ * import storeBuddy from "store-buddy";
+ *
+ * // "foo" is the key used to access the stored value, which is created in the
+ * // method `init`
+ * const storage1 = storeBuddy("foo").init("bar");
+ *
+ * // Using sessionStorage instead of localStorage is possible by specifying
+ * // `true` in the `session` parameter
+ * const storage2 = storeBuddy("foo", true).init("bar");
+ *
+ * // Type safety can be enabled by providing an argument to the type parameter
+ * type Data = {
+ *   hello: string;
+ *   world: number;
+ * }
+ *
+ * const storage3 = storeBuddy<Data>("foo").init({
+ *   hello: "foo",
+ *   world: 123
+ * })
+ * ```
+ */
+export function storeBuddy(key, session = false) {
+    return {
+        init(initialData) {
+            const sessionOrLocal = session ? sessionStorage : localStorage;
+            if (sessionOrLocal.getItem(key) === null) {
+                sessionOrLocal.setItem(key, JSON.stringify(initialData));
+            }
+            return {
+                load() {
+                    const raw = sessionOrLocal.getItem(key);
+                    if (raw === null) {
+                        throw new Error('store-buddy: data has not been set or cannot be recognised');
+                    }
+                    const data = JSON.parse(raw);
+                    return data;
+                },
+                save: (data) => {
+                    sessionOrLocal.setItem(key, JSON.stringify(data));
+                },
+                reset: () => {
+                    sessionOrLocal.setItem(key, JSON.stringify(initialData));
+                },
+                clear: () => {
+                    sessionOrLocal.removeItem(key);
+                },
+            };
+        },
+    };
+}

package/dist/lib/utils/time.js

@@ -0,0 +1,13 @@
+export const sleep = async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+};
+const calc = (m) => (n) => Math.round(n * m);
+export const ms = {
+    seconds: calc(1e3),
+    minutes: calc(6e4),
+    hours: calc(36e5),
+    days: calc(864e5),
+    weeks: calc(6048e5),
+    months: calc(26298e5),
+    years: calc(315576e5),
+};

package/dist/lib/worker/md5.js

@@ -0,0 +1,18 @@
+import { workerMd5Script } from './workerCodes.js';
+export async function md5(data) {
+    return await new Promise((resolve, reject) => {
+        const worker = new Worker(URL.createObjectURL(new Blob([workerMd5Script], { type: 'text/javascript' })));
+        worker.addEventListener('error', reject);
+        worker.addEventListener('messageerror', reject);
+        worker.addEventListener('message', ({ data }) => {
+            if (data.event === 'md5-result') {
+                worker.terminate();
+                resolve(data.data);
+            }
+        });
+        worker.postMessage({
+            event: 'md5',
+            data,
+        });
+    });
+}

package/dist/lib/worker/sodium.js

@@ -0,0 +1,95 @@
+import { workerSodiumScript } from './workerCodes.js';
+// const ensureNonDetachedUniqueBuffers = (
+//   values: Transferable[]
+// ): Set<Transferable> =>
+//   new Set(
+//     values.filter(v => {
+//       if (v instanceof ArrayBuffer) {
+//         return v.byteLength === 0;
+//       } else {
+//         return true;
+//       }
+//     })
+//   );
+export async function encrypt(key, dataToEncrypt, progress, signal) {
+    return await new Promise((resolve, reject) => {
+        void progress?.({
+            current: 0,
+            percent: 0,
+            total: dataToEncrypt.byteLength,
+        });
+        const worker = new Worker(URL.createObjectURL(new Blob([workerSodiumScript], { type: 'text/javascript' })));
+        worker.addEventListener('error', reject);
+        worker.addEventListener('messageerror', reject);
+        worker.addEventListener('message', ({ data }) => {
+            switch (data.event) {
+                case 'ready': {
+                    const postData = {
+                        event: 'encrypt',
+                        data: dataToEncrypt,
+                        key,
+                    };
+                    worker.postMessage(postData, {
+                        transfer: [postData.data.buffer],
+                    });
+                    break;
+                }
+                case 'encrypt-progress': {
+                    if (signal?.aborted === true) {
+                        const abortError = new Error('Aborted');
+                        abortError.name = 'AbortError';
+                        worker.terminate();
+                        reject(abortError);
+                    }
+                    void progress?.(data.data);
+                    break;
+                }
+                case 'encrypt-result': {
+                    worker.terminate();
+                    resolve(data.data);
+                }
+            }
+        });
+    });
+}
+export async function decrypt(key, dataToDecrypt, progress, signal) {
+    return await new Promise((resolve, reject) => {
+        void progress?.({
+            current: 0,
+            percent: 0,
+            total: dataToDecrypt.byteLength,
+        });
+        const worker = new Worker(URL.createObjectURL(new Blob([workerSodiumScript], { type: 'text/javascript' })));
+        worker.addEventListener('error', reject);
+        worker.addEventListener('messageerror', reject);
+        worker.addEventListener('message', ({ data }) => {
+            switch (data.event) {
+                case 'ready': {
+                    const postData = {
+                        event: 'decrypt',
+                        key,
+                        data: dataToDecrypt,
+                    };
+                    worker.postMessage(postData, {
+                        transfer: [postData.data.buffer],
+                    });
+                    break;
+                }
+                case 'decrypt-progress': {
+                    if (signal?.aborted === true) {
+                        const abortError = new Error('Aborted');
+                        abortError.name = 'AbortError';
+                        worker.terminate();
+                        reject(abortError);
+                    }
+                    void progress?.(data.data);
+                    break;
+                }
+                case 'decrypt-result': {
+                    worker.terminate();
+                    resolve(data.data);
+                }
+            }
+        });
+    });
+}

package/dist/{worker → lib/worker}/workerCodes.js

@@ -1,4 +1,4 @@
-const e=`let sodium;
+export const workerSodiumScript = `let sodium;
 
 self.sodium = {
   onload: (sod) => {
@@ -221,7 +221,8 @@ self.onmessage = async ({ data }) => {
       break;
     }
   }
-}`,t=`importScripts('https://cdnjs.cloudflare.com/ajax/libs/spark-md5/3.0.0/spark-md5.min.js');
+}`;
+export const workerMd5Script = `importScripts('https://cdnjs.cloudflare.com/ajax/libs/spark-md5/3.0.0/spark-md5.min.js');
 
 function* chunks(arr, n) {
   for (let i = 0; i < arr.length; i += n) {
@@ -250,5 +251,4 @@ self.onmessage = ({ data }) => {
       break;
     }
   }
-}`;export{t as workerMd5Script,e as workerSodiumScript};
-//# sourceMappingURL=workerCodes.js.map
+}`;

package/dist/types/base-client.d.ts

@@ -0,0 +1,29 @@
+import { type ApiClient, type RouterOutputs, type RouterInputs } from './client.js';
+import { type InfuraNetwork, type PublicUser } from './index.js';
+import { type SelfUser } from './client/types/user.js';
+export declare class BaseClient {
+    static readonly getBaseClient: (session?: string | null | undefined) => ApiClient;
+    protected client: ApiClient;
+    sessionId: string;
+    constructor(session: string);
+    logout(sessionId?: string | null | undefined): Promise<void>;
+    me(): Promise<SelfUser>;
+    static user(userId: string, sessionId?: string | null | undefined): Promise<PublicUser>;
+    user(userId: string): Promise<PublicUser>;
+    searchUsers(search: string): Promise<PublicUser[]>;
+    updateProfile(data: RouterInputs['user']['updateProfile']): Promise<SelfUser>;
+    static isCryptoTransactionDone({ idOrHash, network, }: {
+        idOrHash: string;
+        network?: InfuraNetwork;
+    }): Promise<boolean>;
+    reportUser(data: RouterInputs['report']['create']): Promise<RouterOutputs['report']['create']>;
+    getSponsorshipLink({ backUrl, }: {
+        backUrl: string;
+    }): Promise<string | null>;
+    static getPaymentRequest: ({ paymentRequestId, secrecyIdSeller, }: {
+        paymentRequestId: string;
+        secrecyIdSeller: string;
+        secrecyId?: string | undefined;
+        appCode?: string | undefined;
+    }) => Promise<RouterOutputs['stripe']['paymentRequestToPay']>;
+}

package/dist/types/cache.d.ts

@@ -0,0 +1,9 @@
+import type { InternalNode, InternalFile, InternalNodeFull } from './client/types/index.js';
+export declare const filesCache: Map<string, InternalFile>;
+export declare const nodesCache: Map<string, InternalNode | InternalNodeFull>;
+export declare const usersCache: Map<string, {
+    id: string;
+    lastname: string;
+    firstname: string;
+}>;
+export declare const publicKeysCache: Map<string, string>;

package/dist/types/client/SecrecyAppClient.d.ts

@@ -0,0 +1,18 @@
+import type { SecrecyClient, UserAppNotifications, UserAppSettings } from '../index.js';
+import type { JwtPayload } from 'jsonwebtoken';
+import { type RouterOutputs, type ApiClient } from '../client.js';
+import { type KeyPair } from './types/index.js';
+export declare class SecrecyAppClient {
+    #private;
+    jwt: string;
+    jwtDecoded: JwtPayload;
+    constructor(uaJwt: string, _client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
+    get userId(): string;
+    getJwt(): Promise<string>;
+    limits(): Promise<RouterOutputs['application']['limits']>;
+    updateNotifications(notifications: Partial<UserAppNotifications>): Promise<UserAppNotifications>;
+    notifications(): Promise<UserAppNotifications>;
+    userPublicKey(userId: string): Promise<string>;
+    settings(): Promise<UserAppSettings>;
+    updateSettings(settings: Partial<UserAppSettings>): Promise<UserAppSettings>;
+}

package/dist/types/client/SecrecyCloudClient.d.ts

@@ -0,0 +1,88 @@
+import type { ProgressCallback, SecrecyClient } from '../index.js';
+import type { FileMetadata, KeyPair, Node, NodeFull, NodeType, Rights } from './types/index.js';
+import { type ApiClient } from '../client.js';
+import { type DownloadProgress } from '../types.js';
+export declare class SecrecyCloudClient {
+    #private;
+    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
+    addFileToHistory({ fileId, nodeId, }: {
+        fileId: string;
+        nodeId: string;
+    }): Promise<NodeFull>;
+    uploadFile({ file, encryptProgress, uploadProgress, signal, }: {
+        file: globalThis.File | Uint8Array;
+        encryptProgress?: ProgressCallback;
+        uploadProgress?: ProgressCallback;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    uploadFileInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }: {
+        file: globalThis.File | Uint8Array;
+        name: string;
+        nodeId?: string;
+        encryptProgress?: ProgressCallback;
+        uploadProgress?: ProgressCallback;
+        signal?: AbortSignal;
+    }): Promise<NodeFull>;
+    deletedNodes(): Promise<Node[]>;
+    sharedNodes(): Promise<Node[]>;
+    nodesSharedWithMe(type?: NodeType): Promise<Node[]>;
+    deleteNodeSharing({ nodeId, userId, }: {
+        nodeId: string;
+        userId: string;
+    }): Promise<boolean>;
+    duplicateNode({ nodeId, folderId, customName, }: {
+        nodeId: string;
+        folderId?: string | null | undefined;
+        customName?: string | null | undefined;
+    }): Promise<boolean>;
+    deleteNodeCloudTrash({ ids }: {
+        ids: string[];
+    }): Promise<boolean>;
+    createFolder({ name, parentFolderId, }: {
+        name: string;
+        parentFolderId?: string | null;
+    }): Promise<NodeFull>;
+    node({ id, deleted, }?: {
+        id?: string | null | undefined;
+        deleted?: boolean | null | undefined;
+    }): Promise<NodeFull>;
+    fileMetadata({ id }: {
+        id: string;
+    }): Promise<FileMetadata>;
+    shareNode({ nodeId, userId, rights, }: {
+        nodeId: string;
+        userId: string;
+        rights: Rights;
+    }): Promise<boolean>;
+    updateNode({ nodeId, name, isFavorite, deletedAt, }: {
+        nodeId: string;
+        name?: string | null | undefined;
+        isFavorite?: boolean | null | undefined;
+        deletedAt?: Date | null | undefined;
+    }): Promise<NodeFull>;
+    fileContent({ fileId, onDownloadProgress, progressDecrypt, signal, }: {
+        fileId: string;
+        onDownloadProgress?: (progress: DownloadProgress) => void;
+        progressDecrypt?: ProgressCallback;
+        signal?: AbortSignal;
+    }): Promise<Uint8Array>;
+    deleteFile({ fileId, nodeId, }: {
+        fileId: string;
+        nodeId: string;
+    }): Promise<boolean>;
+    deleteNode({ nodeId }: {
+        nodeId: string;
+    }): Promise<boolean>;
+    emptyTrash(): Promise<boolean>;
+    recoverNode(id: string): Promise<boolean>;
+    moveNodes({ nodeIds, parentNodeId, }: {
+        nodeIds: string[];
+        parentNodeId?: string | null | undefined;
+    }): Promise<boolean>;
+    saveInCloud({ fileId, name, nodeId, }: {
+        fileId: string;
+        name: string;
+        nodeId?: string;
+    }): Promise<NodeFull>;
+    private readonly perNode;
+}

package/dist/types/client/SecrecyDbClient.d.ts

@@ -0,0 +1,30 @@
+import type { SecrecyClient } from '../index.js';
+import type { Document } from 'bson';
+import { type RouterInputs, type ApiClient } from '../client.js';
+import { type KeyPair } from './types/index.js';
+import { type UserData } from '../types.js';
+import { type MongoDbEnv } from '@secrecy/trpc-api-types';
+export declare class SecrecyDbClient {
+    #private;
+    constructor(_client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
+    get<U>(opts: RouterInputs['db']['field']): Promise<U>;
+    /**
+     * Set an user document.
+     */
+    set<T extends UserData, U extends Document>({ value, userId, }: {
+        value: U;
+        userId?: string | null | undefined;
+    }): Promise<T>;
+    /**
+     * Searches for user fields that match the search arguments.
+     */
+    search<T>({ appId, env, search, field, take, skip, orderBy, }: {
+        appId: string;
+        env: MongoDbEnv;
+        field: string;
+        search: string;
+        take: number | null;
+        skip: number | null;
+        orderBy: 'createdAt_ASC' | 'createdAt_DESC' | null;
+    }): Promise<T[]>;
+}

package/dist/types/client/SecrecyMailClient.d.ts

@@ -0,0 +1,42 @@
+import { type ApiClient } from '../client.js';
+import type { DraftMail, Mail, NewMail, ReceivedMail, SecrecyClient, SentMail, WaitingReceivedMail } from '../index.js';
+import { type KeyPair } from './types/index.js';
+import { type ApiMail } from './types/mail.js';
+export declare class SecrecyMailClient {
+    #private;
+    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
+    get({ id }: {
+        id: string;
+    }): Promise<Mail>;
+    recover({ mailId }: {
+        mailId: string;
+    }): Promise<boolean>;
+    deletedMails({ mailType, }: {
+        mailType: ApiMail['type'];
+    }): Promise<Mail[]>;
+    create(data: NewMail, customMessage?: string | null | undefined): Promise<boolean>;
+    waitingReceivedMails(): Promise<WaitingReceivedMail[]>;
+    updateDraft(draftId: string, { body, subject, senderFiles, recipients, replyToId }: Partial<NewMail>): Promise<DraftMail>;
+    deleteDraft(draftId: string): Promise<boolean>;
+    deleteTrash({ ids }: {
+        ids: string[];
+    }): Promise<boolean>;
+    emptyTrash(): Promise<boolean>;
+    delete({ mailId }: {
+        mailId: string;
+    }): Promise<boolean>;
+    sendDraft(draftId: string, customMessage?: string | null | undefined): Promise<boolean>;
+    sendWaitingEmails(): Promise<void>;
+    createDraft({ body, subject, senderFiles, recipients, replyToId, }: NewMail): Promise<DraftMail>;
+    read({ mailId }: {
+        mailId: string;
+    }): Promise<boolean>;
+    unread({ mailId }: {
+        mailId: string;
+    }): Promise<boolean>;
+    receivedMails(): Promise<ReceivedMail[]>;
+    sentMails(): Promise<SentMail[]>;
+    draftMails(): Promise<DraftMail[]>;
+    unreadReceivedMailsCount(): Promise<number>;
+    private readonly _eachUser;
+}

package/dist/types/client/SecrecyPayClient.d.ts

@@ -0,0 +1,27 @@
+import type { SecrecyClient } from '../index.js';
+import { type ApiClient } from '../client.js';
+import { type KeyPair } from './types/index.js';
+interface SuccessPayResponse<T> {
+    success: true;
+    data: T;
+}
+interface ErrorPayResponse {
+    success: false;
+    error: string;
+}
+export type SecrecyPayResponse<T> = SuccessPayResponse<T> | ErrorPayResponse;
+export declare class SecrecyPayClient {
+    #private;
+    constructor(client: SecrecyClient, _keys: KeyPair, _apiClient: ApiClient);
+    confirmPaymentIntent({ paymentIntentId, secrecyIdWhoCreatedPaymentIntent, secrecyIdWhoNeedToConfirmPaymentIntent, amount, currency, }: {
+        paymentIntentId: string;
+        secrecyIdWhoCreatedPaymentIntent: string;
+        secrecyIdWhoNeedToConfirmPaymentIntent: string;
+        amount: number;
+        currency: 'eur' | 'usd';
+    }): Promise<SecrecyPayResponse<{
+        id: string;
+        message: string;
+    }>>;
+}
+export {};