@secrecy/lib 1.7.0 → 1.8.0

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

@@ -0,0 +1,20 @@
+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']>;
+    metrics(): Promise<RouterOutputs['application']['metrics']>;
+    quotas(): Promise<RouterOutputs['application']['quotas']>;
+    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,7 @@
+import { type ApiClient } from '../client.js';
+import type { SecrecyClient } from '../index.js';
+import { type KeyPair } from './types/index.js';
+export declare class SecrecyDbClient {
+    #private;
+    constructor(_client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
+}

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 {};

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

@@ -0,0 +1,14 @@
+import type { RouterInputs, ApiClient, RouterOutputs } from '../client.js';
+import type { SecrecyClient } from '../index.js';
+import type { KeyPair } from './types/index.js';
+export declare class SecrecyUserClient {
+    #private;
+    constructor(_client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
+    answerInvitation(input: RouterInputs['contacts']['answerInvitation']): Promise<RouterOutputs['contacts']['answerInvitation']>;
+    cancelInvitation(input: RouterInputs['contacts']['cancelInvitation']): Promise<RouterOutputs['contacts']['cancelInvitation']>;
+    createInvitation(input: RouterInputs['contacts']['createInvitation']): Promise<RouterOutputs['contacts']['createInvitation']>;
+    getContacts(input: RouterInputs['contacts']['getContacts']): Promise<RouterOutputs['contacts']['getContacts']>;
+    getReceivedInvitations(input: RouterInputs['contacts']['getReceivedInvitations']): Promise<RouterOutputs['contacts']['getReceivedInvitations']>;
+    getSentInvitations(input: RouterInputs['contacts']['getSentInvitations']): Promise<RouterOutputs['contacts']['getSentInvitations']>;
+    removeContact(input: RouterInputs['contacts']['removeContact']): Promise<RouterOutputs['contacts']['removeContact']>;
+}

package/dist/{client → types/client}/SecrecyWalletClient.d.ts

@@ -1,28 +1,25 @@
-import type { SecrecyClient, SecrecyEnv } from "../index.js";
-import { InfuraNetwork } from "../zeus/index.js";
-import type { providers } from "ethers";
-type SuccessWalletResponse<T> = {
+import type { SecrecyClient, InfuraNetwork } from '../index.js';
+import { type TransactionRequest } from 'ethers';
+interface SuccessWalletResponse<T> {
     success: true;
     data: T;
-};
-type ErrorWalletResponse = {
+}
+interface ErrorWalletResponse {
     success: false;
     error: string;
-};
+}
 export type SecrecyWalletResponse<T> = SuccessWalletResponse<T> | ErrorWalletResponse;
 export declare class SecrecyWalletClient {
     #private;
     constructor(client: SecrecyClient);
-    createTransaction({ env, network, tx }: {
-        env?: SecrecyEnv;
+    createTransaction({ network, tx, }: {
         network?: InfuraNetwork;
-        tx: providers.TransactionRequest;
+        tx: TransactionRequest;
     }): Promise<SecrecyWalletResponse<{
         id: string;
         hash: string;
     }>>;
-    createSignature({ env, network, message }: {
-        env?: SecrecyEnv;
+    createSignature({ network, message, }: {
         network?: InfuraNetwork;
         message: string;
     }): Promise<SecrecyWalletResponse<string>>;

package/dist/types/client/convert/file.d.ts

@@ -0,0 +1,4 @@
+import type { ApiFile, InternalFile, FileMetadata, KeyPair } from '../types/index.js';
+export declare function apiFileToInternal(apiFile: ApiFile, keyPair: KeyPair): InternalFile;
+export declare function internalFileToFile(internal: InternalFile): FileMetadata;
+export declare function apiFileToExternal(apiFile: ApiFile, keyPair: KeyPair): FileMetadata;

package/dist/types/client/convert/mail.d.ts

@@ -0,0 +1,8 @@
+import { type Mail, type SecrecyClient } from '../../index.js';
+import { type KeyPair } from '../types/index.js';
+import { type ApiMail } from '../types/mail.js';
+export declare function convertInternalMailToExternal({ client, mail, keyPair, }: {
+    mail: ApiMail;
+    client: SecrecyClient;
+    keyPair: KeyPair;
+}): Promise<Mail>;

package/dist/types/client/convert/node.d.ts

@@ -0,0 +1,7 @@
+import type { Node, ApiNode, InternalNode, ApiNodeFull, InternalNodeFull, NodeFull, KeyPair } from '../types/index.js';
+export declare function apiNodeToInternal(apiNode: ApiNode | ApiNodeFull, keyPair: KeyPair): Promise<InternalNode>;
+export declare function apiNodeFullToInternalFull(apiNodeFull: ApiNodeFull, keyPair: KeyPair): Promise<InternalNodeFull>;
+export declare function internalNodeToNode(internal: InternalNode): Node;
+export declare function internalNodeFullToNodeFull(internal: InternalNodeFull): NodeFull;
+export declare function apiNodeToExternalNodeFull(apiNodeFull: ApiNodeFull, keyPair: KeyPair): Promise<NodeFull>;
+export declare function apiNodeToExternal(apiNode: ApiNode, keyPair: KeyPair): Promise<Node>;

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

@@ -0,0 +1,26 @@
+import { SecrecyClient } from './index.js';
+import { type SecrecyUserApp } from './types/index.js';
+export declare function parseInfos(): SecrecyUserApp | null;
+export declare const getUrl: ({ hash, path, }: {
+    hash: string;
+    path: string;
+}) => string;
+export interface HashInfos {
+    appId: string;
+    appUrl: string;
+    backPath?: string;
+    path?: string | null | undefined;
+    redirect?: boolean;
+    scopes?: {
+        email: boolean;
+    };
+}
+export type UseSecrecyParams = Omit<HashInfos, 'appUrl'> & {
+    session?: boolean | undefined;
+};
+export declare function getSecrecyClient(session?: boolean): SecrecyClient | null;
+type LoginResponse<Params extends UseSecrecyParams> = Params extends {
+    redirect: true;
+} ? SecrecyClient | null : SecrecyClient;
+export declare function login<Params extends UseSecrecyParams>({ appId, path, redirect, scopes, backPath, session, }: Params): Promise<LoginResponse<Params>>;
+export {};

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

@@ -0,0 +1,29 @@
+import { BaseClient } from '../base-client.js';
+import type { Progress } from '../crypto/file.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 RouterInputs } from '../client.js';
+import { type KeyPair } from './types/index.js';
+import { SecrecyUserClient } from './SecrecyUserClient.js';
+import { SecrecyCareClient } from './SecrecryCareClient.js';
+export type NewMail = Pick<RouterInputs['mail']['createDraft'], 'body' | 'subject' | 'senderFiles' | 'recipients' | 'replyToId'>;
+export type ProgressCallback = (progress: Progress) => Promise<void>;
+export declare const encryptName: (name: string, nameKey: string) => Promise<string>;
+export declare class SecrecyClient extends BaseClient {
+    #private;
+    care: SecrecyCareClient;
+    cloud: SecrecyCloudClient;
+    mail: SecrecyMailClient;
+    app: SecrecyAppClient;
+    db: SecrecyDbClient;
+    wallet: SecrecyWalletClient;
+    pay: SecrecyPayClient;
+    user: SecrecyUserClient;
+    constructor(uaSession: string, uaKeys: KeyPair, uaJwt: string);
+    get publicKey(): string;
+    logout(sessionId?: string | null | undefined): Promise<void>;
+}

package/dist/{client → types/client}/storage.d.ts

@@ -1,5 +1,5 @@
-import type { KeyPair } from "../index.js";
-import type { StoreBuddy } from "../utils/store-buddy.js";
+import type { StoreBuddy } from '../utils/store-buddy.js';
+import { type KeyPair } from './types/index.js';
 export declare function getStorage(session?: boolean | undefined): {
     userAppKeys: StoreBuddy<KeyPair | null>;
     userAppSession: StoreBuddy<string | null>;

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

@@ -0,0 +1,2 @@
+import type { RouterOutputs } from '../../client';
+export type Application = RouterOutputs['tech']['application'];

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

@@ -0,0 +1,6 @@
+import { type RouterOutputs } from '../../client.js';
+export type FileMetadata = Pick<ApiFile, 'id' | 'size' | 'sizeBefore' | 'md5' | 'md5Encrypted' | 'createdAt'>;
+export type InternalFile = FileMetadata & {
+    key: string;
+};
+export type ApiFile = NonNullable<RouterOutputs['cloud']['fileById']>;

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export type * from './app.js';
+export type * from './file.js';
+export type * from './node.js';
+export type * from './mail.js';
+export type * from './user.js';
+declare const keyPair: z.ZodObject<{
+    publicKey: z.ZodString;
+    privateKey: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    publicKey: string;
+    privateKey: string;
+}, {
+    publicKey: string;
+    privateKey: string;
+}>;
+export type KeyPair = z.infer<typeof keyPair>;
+export declare const secrecyUserApp: z.ZodReadonly<z.ZodObject<{
+    keys: z.ZodObject<{
+        publicKey: z.ZodString;
+        privateKey: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        publicKey: string;
+        privateKey: string;
+    }, {
+        publicKey: string;
+        privateKey: string;
+    }>;
+    jwt: z.ZodString;
+    uaSession: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    keys: {
+        publicKey: string;
+        privateKey: string;
+    };
+    jwt: string;
+    uaSession: string;
+}, {
+    keys: {
+        publicKey: string;
+        privateKey: string;
+    };
+    jwt: string;
+    uaSession: string;
+}>>;
+export type SecrecyUserApp = z.infer<typeof secrecyUserApp>;

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

@@ -0,0 +1,87 @@
+import { type RouterOutputs } from '../../client.js';
+import { type PublicUser } from './user.js';
+export type MailType = 'sent' | 'received' | 'draft';
+export type ApiMail = RouterOutputs['mail']['byId'];
+export interface BaseMail {
+    type: MailType;
+    id: string;
+    mailIntegrityId: string;
+    replyTo?: string;
+    body: string;
+    subject: string;
+    createdAt: Date;
+    deletedAt: Date | null;
+    openedAt: Date | null;
+    isAltered: boolean;
+    recipients: Array<Omit<PublicUser, 'publicKey'>>;
+    temporaryRecipients: TemporaryMailUser[];
+    files: Array<{
+        id: string;
+        name: string;
+        key: string;
+    }>;
+}
+export interface ReceivedMail extends BaseMail {
+    type: 'received';
+    sender: PublicUser;
+}
+export interface InternalSentMail {
+    user: {
+        sentMails: ApiMail[];
+    };
+}
+export interface InternalDraftMails {
+    user: {
+        draftMails: ApiMail[];
+    };
+}
+export interface SentMail extends BaseMail {
+    type: 'sent';
+}
+export interface DraftMail extends BaseMail {
+    type: 'draft';
+}
+export type Mail = DraftMail | SentMail | ReceivedMail;
+export interface MailIntegrity {
+    id: string;
+    hash: string;
+    hashKey: string;
+    replyTo?: {
+        id: string;
+    };
+    temporaryRecipients: TemporaryMailUser[];
+    recipients: PublicUser[];
+}
+export type MailIntegrityDraft = MailIntegrity & {
+    recipients: PublicUser[];
+};
+export interface TemporaryMailUser {
+    email?: string;
+}
+export interface InternalWaitingReceivedMail {
+    sender: PublicUser;
+    date: string;
+    attachmentsCount: number;
+    recipients: PublicUser[];
+    temporaryRecipients: TemporaryMailUser[];
+}
+export interface WaitingReceivedMail {
+    id: string;
+    sender: PublicUser;
+    date: Date;
+    attachmentsCount: number;
+    recipients: PublicUser[];
+    temporaryRecipients: TemporaryMailUser[];
+}
+export interface MailFile {
+    fileKey: string;
+    filename: string;
+    file: {
+        id: string;
+    };
+}
+export interface InternalReceivedMail {
+    user: {
+        receivedMails: ApiMail[];
+    };
+}

package/dist/{client/types/Node.d.ts → types/client/types/node.d.ts}

@@ -1,33 +1,27 @@
-import type { NodeType, Rights } from "../../zeus/index.js";
-import type { FileMetadata, InternalFile, PublicUser } from "./index.js";
-import type { nodeFullSelector, nodeSelector } from "./selectors.js";
-import type { GraphQLTypes, InputType } from "../../zeus/index.js";
+import { type RouterOutputs } from '../../client.js';
+import type { FileMetadata, InternalFile, PublicUser } from './index.js';
+export type Rights = ApiNode['users'][number][1];
 export type NodeAccess<T extends Record<string, unknown> = Record<string, unknown>> = T & {
     rights: Rights;
     isRoot: boolean;
-    sharedBy: {
-        keyPair?: {
-            pub: string;
-        };
-    };
-    userApp: {
-        user: PublicUser;
-    };
+    sharedByPubKey: string;
 };
-export type NodeBreadcrumbItem = {
+export interface NodeBreadcrumbItem {
     id: string;
     name: string;
+}
+export interface NodeBreadcrumbItemWithPubKey extends NodeBreadcrumbItem {
     pubKey: string;
-};
-export type NodeSize = {
+}
+export interface NodeSize {
     size: bigint;
     sizeBefore: bigint;
-};
+}
 type NameKey = {
-    nameKey?: string;
+    nameKey: string | null;
 };
-export type InternalNodeBreadcrumbItem = NodeBreadcrumbItem & NameKey;
-export type Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Record<string, unknown> = Record<string, unknown>> = {
+export type InternalNodeBreadcrumbItem = NodeBreadcrumbItemWithPubKey & NameKey;
+export interface Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Record<string, unknown> = Record<string, unknown>> {
     id: string;
     isFavorite: boolean;
     type: NodeType;
@@ -38,19 +32,20 @@ export type Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Re
     name: string;
     breadcrumb: T[];
     createdBy: PublicUser;
-    access?: NodeAccess<U>;
-    users: [PublicUser, Rights][];
+    access: NodeAccess<U>;
+    users: Array<[PublicUser, Rights]>;
     parentId: string | null;
     currentFileId: string | null;
-};
+}
 export type NodeFull<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Record<string, unknown> = Record<string, unknown>, V extends FileMetadata = FileMetadata> = Node<T, U> & {
     parent: Node<T, U> | null;
-    children: Node<T, U>[];
+    children: Array<Node<T, U>>;
     current?: V;
     history: V[];
 };
 export type InternalNode = Node<InternalNodeBreadcrumbItem, NameKey>;
 export type InternalNodeFull = NodeFull<InternalNodeBreadcrumbItem, NameKey, InternalFile>;
-export type GQLNode = InputType<GraphQLTypes["Node"], typeof nodeSelector>;
-export type GQLNodeFull = InputType<GraphQLTypes["Node"], typeof nodeFullSelector>;
+export type ApiNode = RouterOutputs['cloud']['nodeById'];
+export type ApiNodeFull = RouterOutputs['cloud']['nodeFullById'];
+export type NodeType = ApiNode['type'];
 export {};

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

@@ -0,0 +1,3 @@
+import { type RouterOutputs } from '../../client.js';
+export type SelfUser = RouterOutputs['user']['self'];
+export type PublicUser = RouterOutputs['user']['byId'];