@secrecy/lib 1.86.2-fix-md5.1 → 1.86.3

package/dist/lib/worker/workerCodes.js

@@ -0,0 +1,254 @@
+export const workerSodiumScript = `let sodium;
+
+self.sodium = {
+  onload: (sod) => {
+    sodium = sod
+    postMessage({ event: "ready" })
+  }
+};
+
+importScripts('https://cdn.jsdelivr.net/gh/jedisct1/libsodium.js@0.7.15/dist/browsers/sodium.js');
+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) {
+    yield arr.slice(i, i + n);
+  }
+}
+
+function assert(c, message) {
+  if (!c) {
+    throw new Error(message);
+  }
+}
+
+function encrypt(key) {
+  let destroyed = false;
+  const {
+    state,
+    header
+  } = sodium.crypto_secretstream_xchacha20poly1305_init_push(key);
+
+  const encrypt = (tag, plaintext) => {
+    assert(destroyed === false, "state already destroyed");
+
+    return sodium.crypto_secretstream_xchacha20poly1305_push(
+      state,
+      plaintext,
+      null,
+      tag
+    );
+  };
+
+  function destroy() {
+    assert(destroyed === false, "state already destroyed");
+    destroyed = true;
+  }
+
+  return {
+    encrypt,
+    destroy,
+    header
+  };
+}
+
+function decrypt(header, key) {
+  assert(
+    header.byteLength >=
+      sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES,
+    "header must be at least HEADERBYTES (" + sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES + ") long"
+  );
+  assert(
+    key.byteLength >= sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES,
+    "key must be at least KEYBYTES (" + sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES + ") long"
+  );
+
+  let destroyed = false;
+  const state = sodium.crypto_secretstream_xchacha20poly1305_init_pull(
+    header,
+    key
+  );
+
+  const decrypt = ciphertext => {
+    assert(destroyed === false, "state already destroyed");
+
+    return sodium.crypto_secretstream_xchacha20poly1305_pull(state, ciphertext);
+  };
+
+  function destroy() {
+    assert(destroyed === false, "state already destroyed");
+    destroyed = true;
+  }
+
+  return {
+    decrypt,
+    destroy
+  };
+}
+
+const CHUNK_SIZE = 8192;
+
+async function encryptSecretstream(key, data, progress) {
+  const { encrypt: crypt, destroy, header } = encrypt(key);
+  const cryptedChunk =
+    CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
+  const max =
+    Math.ceil(data.byteLength / CHUNK_SIZE) * cryptedChunk + header.byteLength;
+
+  progress?.({
+    percent: 0,
+    total: max,
+    current: 0
+  });
+  const final = new Uint8Array(max);
+  const sparkEncrypted = new SparkMD5.ArrayBuffer();
+  const spark = new SparkMD5.ArrayBuffer();
+
+  final.set(header);
+  sparkEncrypted.append(header);
+  let total = header.byteLength;
+  progress?.({
+    percent: total / max,
+    total: max,
+    current: total
+  });
+  let lastPercent = total / max;
+
+  for (const chunk of chunks(data, CHUNK_SIZE)) {
+    spark.append(chunk);
+    const tag =
+      chunk.length < CHUNK_SIZE
+        ? sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL
+        : sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE;
+    const crypted = crypt(tag, chunk);
+    sparkEncrypted.append(crypted);
+    final.set(crypted, total);
+    total += crypted.byteLength;
+    const percent = total / max;
+    if (percent > lastPercent + 0.01) {
+      progress?.({
+        percent,
+        total: max,
+        current: total
+      });
+      lastPercent = percent;
+    }
+  }
+
+  destroy();
+  progress?.({
+    percent: 1,
+    total,
+    current: total
+  });
+  return {
+    data: final.slice(0, total),
+    md5Encrypted: sparkEncrypted.end(),
+    md5: spark.end()
+  };
+}
+
+async function decryptSecretstream(key, data, progress) {
+  const header = data.slice(
+    0,
+    sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES
+  );
+  data = data.slice(sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+
+  const { decrypt: decryptt, destroy } = decrypt(header, key);
+  const chunkSize =
+    CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
+  const max = Math.ceil(data.byteLength / chunkSize) * CHUNK_SIZE;
+
+  progress?.({
+    percent: 0,
+    total: max,
+    current: 0
+  });
+  const final = new Uint8Array(max);
+  let total = 0;
+  let lastPercent = total / max;
+
+  for (const chunk of chunks(data, chunkSize)) {
+    const tmp = decryptt(chunk);
+    final.set(tmp.message, total);
+    total += tmp.message.byteLength;
+
+    const percent = total / max;
+    if (percent > lastPercent + 0.01) {
+      progress?.({
+        percent,
+        total: max,
+        current: total
+      });
+      lastPercent = percent;
+    }
+  }
+
+  destroy();
+  progress?.({
+    percent: 1,
+    total,
+    current: total
+  });
+  return final.slice(0, total);
+}
+
+self.onmessage = async ({ data }) => {
+  switch (data.event) {
+    case "encrypt": {
+      postMessage({ event: "working" })
+      postMessage({
+        event: "encrypt-result",
+        data: await encryptSecretstream(data.key, data.data, progress => postMessage({
+          event: "encrypt-progress",
+          data: progress
+        }))
+      });
+      postMessage({ event: "ready" })
+      break;
+    }
+    case "decrypt": {
+      postMessage({ event: "working" })
+      postMessage({
+        event: "decrypt-result",
+        data: await decryptSecretstream(data.key, data.data, progress => postMessage({
+          event: "decrypt-progress",
+          data: progress
+        }))
+      });
+      postMessage({ event: "ready" })
+      break;
+    }
+  }
+}`;
+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) {
+    yield arr.slice(i, i + n);
+  }
+}
+
+const CHUNK_SIZE = 8192;
+
+function md5(data) {
+  const spark = new SparkMD5.ArrayBuffer();
+  for (const chunk of chunks(data, CHUNK_SIZE)) {
+    spark.append(chunk);
+  }
+  return spark.end();
+}
+
+
+self.onmessage = ({ data }) => {
+  switch (data.event) {
+    case "md5": {
+      postMessage({
+        event: "md5-result",
+        data: md5(data.data)
+      });
+      break;
+    }
+  }
+}`;

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

@@ -12,6 +12,8 @@ export type BaseClientOptions = {
     apiClient?: ApiClient;
     onAccessDenied?: () => void | Promise<void>;
     secrecyUrls?: Partial<SecrecyUrls>;
+    timeoutMs?: number;
+    reloadOnAccessDenied?: boolean;
 };
 export declare class BaseClient {
     #private;

package/dist/types/cache.d.ts

@@ -1,17 +1,18 @@
 import type { InternalNode, InternalData, InternalNodeFull, LocalData, InternalMinimalNodeForEncryption } from './client/types/index.js';
 import { LRUCache } from 'lru-cache';
 type NodeForEncryptionCached = InternalNode | InternalNodeFull | InternalMinimalNodeForEncryption;
-export declare const dataCache: Map<string, InternalData>;
-export declare const nodesCache: Map<string, InternalNode | InternalNodeFull>;
-export declare const nodesEncryptionCache: Map<string, InternalMinimalNodeForEncryption>;
+export declare const dataCache: LRUCache<string, InternalData, unknown>;
+export declare const nodesCache: LRUCache<string, InternalNode | InternalNodeFull, unknown>;
+export declare const nodesEncryptionCache: LRUCache<string, InternalMinimalNodeForEncryption, unknown>;
 export declare const getNodeForEncryptionFromCache: (id: string) => NodeForEncryptionCached | undefined;
-export declare const usersCache: Map<string, {
+export declare const usersCache: LRUCache<string, {
     firstname: string;
     lastname: string;
     id: string;
     avatar: string | null;
     isSearchable: boolean;
-}>;
-export declare const publicKeysCache: Map<string, string>;
+}, unknown>;
+export declare const publicKeysCache: LRUCache<string, string, unknown>;
 export declare const dataContentCache: LRUCache<string, LocalData, unknown>;
+export declare function clearAllCaches(): void;
 export {};

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

@@ -13,9 +13,23 @@ export declare class SecrecyMailClient {
     deletedMails({ mailType, }: {
         mailType: ApiMail['type'];
     }): Promise<Mail[]>;
+    create(data: NewMail & {
+        customMessage?: string | null | undefined;
+    }): Promise<SentMail>;
+    /**
+     * @deprecated Pass a single object instead:
+     * `create({ ...data, customMessage })`.
+     */
     create(data: NewMail, customMessage?: string | null | undefined): Promise<SentMail>;
     waitingReceivedMails(): Promise<WaitingReceivedMail[]>;
-    updateDraft(draftId: string, { body, subject, senderFiles, recipients, replyToId }: Partial<NewMail>): Promise<DraftMail>;
+    updateDraft(input: {
+        draftId: string;
+    } & Partial<NewMail>): Promise<DraftMail>;
+    /**
+     * @deprecated Pass a single object instead:
+     * `updateDraft({ draftId, ...args })`.
+     */
+    updateDraft(draftId: string, args: Partial<NewMail>): Promise<DraftMail>;
     deleteDraft(draftId: string): Promise<boolean>;
     deleteTrash({ ids }: {
         ids: string[];
@@ -24,6 +38,14 @@ export declare class SecrecyMailClient {
     delete({ mailId }: {
         mailId: string;
     }): Promise<boolean>;
+    sendDraft(input: {
+        draftId: string;
+        customMessage?: string | null | undefined;
+    }): Promise<boolean>;
+    /**
+     * @deprecated Pass a single object instead:
+     * `sendDraft({ draftId, customMessage })`.
+     */
     sendDraft(draftId: string, customMessage?: string | null | undefined): Promise<boolean>;
     sendWaitingEmails(): Promise<void>;
     createDraft({ body, subject, senderFiles, recipients, replyToId, }: NewMail): Promise<DraftMail>;

package/dist/types/client/data-link.d.ts

@@ -3,7 +3,7 @@ import { type ProgressCallback } from '.';
 import { type Progress } from 'ky';
 export declare const downloadDataLinkSchema: z.ZodUnion<readonly [z.ZodObject<{
     name: z.ZodString;
-    md5: z.ZodNullable<z.ZodString>;
+    md5: z.ZodString;
     md5Encrypted: z.ZodNullable<z.ZodString>;
     size: z.ZodCoercedBigInt<unknown>;
     parts: z.ZodArray<z.ZodObject<{
@@ -15,7 +15,7 @@ export declare const downloadDataLinkSchema: z.ZodUnion<readonly [z.ZodObject<{
     isEncrypted: z.ZodBoolean;
 }, z.core.$strip>, z.ZodObject<{
     name: z.ZodString;
-    md5: z.ZodNullable<z.ZodString>;
+    md5: z.ZodString;
     md5Encrypted: z.ZodNullable<z.ZodString>;
     size: z.ZodCoercedBigInt<unknown>;
     bytes: z.ZodString;
@@ -34,7 +34,7 @@ export type DownloadDataFromLinkOptions = {
 };
 export declare function fetchDataLinkMetadata(dataLinkSlug: string, dataUrl?: string): Promise<{
     name: string;
-    md5: string | null;
+    md5: string;
     md5Encrypted: string | null;
     size: bigint;
     parts: {
@@ -46,7 +46,7 @@ export declare function fetchDataLinkMetadata(dataLinkSlug: string, dataUrl?: st
     isEncrypted: boolean;
 } | {
     name: string;
-    md5: string | null;
+    md5: string;
     md5Encrypted: string | null;
     size: bigint;
     bytes: string;

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

@@ -1,6 +1,7 @@
 import { SecrecyClient } from './index.js';
 import { type SecrecyUserApp } from './types/index.js';
 import type { SecrecyUrls } from '../base-client.js';
+export declare function assertBrowser(fn: string): void;
 export declare function parseInfos(): SecrecyUserApp | null;
 export interface HashInfos {
     appId?: string;
@@ -29,4 +30,16 @@ type LoginResponse<Params extends UseSecrecyParams> = Params extends {
     redirect: true;
 } ? SecrecyClient | null : SecrecyClient;
 export declare function login<Params extends UseSecrecyParams>({ appId, context, path, redirect, scopes, backPath, session, secrecyUrls, forceLogin, }: Params): Promise<LoginResponse<Params>>;
+/**
+ * Single async entry point: runs `setup()`, reuses an existing session if
+ * one is found, and falls back to `login()` otherwise. Equivalent to
+ * `await setup()` + `getSecrecyClient()` + `login()`, without having to
+ * juggle the sync/async mismatch between them.
+ */
+export declare function initSecrecy(opts: {
+    appId: string;
+    session?: boolean | undefined;
+    redirect?: boolean | undefined;
+    secrecyUrls?: Partial<SecrecyUrls>;
+}): Promise<SecrecyClient | null>;
 export {};

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

@@ -3,7 +3,6 @@ import type { SecretStreamProgress } from '../crypto/data.js';
 import { SecrecyCloudClient } from './SecrecyCloudClient.js';
 import { SecrecyMailClient } from './SecrecyMailClient.js';
 import { SecrecyAppClient } from './SecrecyAppClient.js';
-import { SecrecyDbClient } from './SecrecyDbClient.js';
 import { SecrecyWalletClient } from './SecrecyWalletClient.js';
 import { SecrecyPayClient } from './SecrecyPayClient.js';
 import { type ApiClient, type RouterInputs } from '../client.js';
@@ -22,15 +21,18 @@ export interface SecrecyClientOptions {
     uaJwt: string;
     apiClient?: ApiClient;
     secrecyUrls?: Partial<SecrecyUrls>;
+    timeoutMs?: number;
+    reloadOnAccessDenied?: boolean;
 }
 export declare class SecrecyClient extends BaseClient {
     #private;
     cloud: SecrecyCloudClient;
     mail: SecrecyMailClient;
     app: SecrecyAppClient;
-    db: SecrecyDbClient;
     organization: SecrecyOrganizationClient;
+    /** @experimental Susceptible de changer sans version majeure. */
     wallet: SecrecyWalletClient;
+    /** @experimental Susceptible de changer sans version majeure. */
     pay: SecrecyPayClient;
     user: SecrecyUserClient;
     pseudonym: SecrecyPseudonymClient;

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

@@ -7,8 +7,7 @@ export type LocalData = {
     storageType: DataStorageType;
     size: bigint;
     sizeEncrypted: bigint | null;
-    /** md5 of the content: only for unencrypted and legacy encrypted data. */
-    md5: string | null;
+    md5: string;
     data: Uint8Array<ArrayBuffer>;
     mime?: string;
     ext?: string;