packages/pass/lib/alias/alias.requests.ts

   1 import { c } from 'ttag';
   2
   3 import { MAX_BATCH_PER_REQUEST } from '@proton/pass/constants';
   4 import { api } from '@proton/pass/lib/api/api';
   5 import { createPageIterator } from '@proton/pass/lib/api/utils';
   6 import { PassCrypto } from '@proton/pass/lib/crypto';
   7 import { serializeItemContent } from '@proton/pass/lib/items/item-proto.transformer';
   8 import { itemBuilder } from '@proton/pass/lib/items/item.builder';
   9 import type {
  10     AliasCreateFromPendingDTO,
  11     AliasDetails,
  12     AliasMailbox,
  13     AliasOptions,
  14     AliasPending,
  15     AliasToggleStatusDTO,
  16     CreatePendingAliasRequest,
  17     EnableSLSyncRequest,
  18     ItemRevisionContentsResponse,
  19     SlSyncStatusOutput,
  20 } from '@proton/pass/types';
  21 import chunk from '@proton/utils/chunk';
  22
  23 export const getAliasOptions = async (shareId: string): Promise<AliasOptions> => {
  24     const aliasOptions = await api({
  25         url: `pass/v1/share/${shareId}/alias/options`,
  26         method: 'get',
  27     }).then(({ Options }) => {
  28         if (!Options) throw new Error(c('Error').t`Alias options could not be resolved`);
  29         return Options;
  30     });
  31
  32     const options: AliasOptions = {
  33         suffixes: aliasOptions.Suffixes.map((data) => ({
  34             signedSuffix: data.SignedSuffix!,
  35             suffix: data.Suffix!,
  36             isCustom: data.IsCustom!,
  37             domain: data.Domain!,
  38         })),
  39         mailboxes: aliasOptions.Mailboxes.map((mailbox) => ({
  40             email: mailbox.Email,
  41             id: mailbox.ID,
  42         })),
  43     };
  44
  45     return options;
  46 };
  47
  48 export const getAliasDetails = async (shareId: string, itemId: string): Promise<AliasDetails> => {
  49     const result = await api({
  50         url: `pass/v1/share/${shareId}/alias/${itemId}`,
  51         method: 'get',
  52     });
  53
  54     return {
  55         aliasEmail: result.Alias!.Email,
  56         mailboxes: result.Alias!.Mailboxes?.map(({ Email, ID }): AliasMailbox => ({ id: ID, email: Email })) ?? [],
  57     };
  58 };
  59
  60 export const getAliasCount = async (): Promise<number> =>
  61     (await api({ url: `pass/v1/user/alias/count`, method: 'get' }))?.AliasCount?.Total ?? 0;
  62
  63 export const getAliasSyncStatus = async (): Promise<SlSyncStatusOutput> => {
  64     const result = (await api({ url: `pass/v1/alias_sync/status`, method: 'get' }))?.SyncStatus;
  65     return result ?? { PendingAliasCount: 0, Enabled: false };
  66 };
  67
  68 export const enableAliasSync = async (data: EnableSLSyncRequest) =>
  69     api({
  70         url: `pass/v1/alias_sync/sync`,
  71         method: 'post',
  72         data,
  73     });
  74
  75 export const getPendingAliases = async (): Promise<AliasPending[]> =>
  76     createPageIterator({
  77         request: async (cursor) => {
  78             const result = await api({ url: `pass/v1/alias_sync/pending`, method: 'get', params: { Since: cursor } });
  79             const pending = (result.PendingAliases?.Aliases ?? []).map<AliasPending>((pending) => ({
  80                 aliasEmail: pending.AliasEmail!,
  81                 pendingAliasID: pending.PendingAliasID!,
  82                 aliasNote: pending.AliasNote!,
  83             }));
  84
  85             return { data: pending, cursor: result.PendingAliases?.LastToken };
  86         },
  87     })();
  88
  89 export const createAliasesFromPending = async ({
  90     shareId,
  91     pendingAliases,
  92 }: AliasCreateFromPendingDTO): Promise<ItemRevisionContentsResponse[]> => {
  93     const encryptedItems: CreatePendingAliasRequest[] = await Promise.all(
  94         pendingAliases.map(async (alias) => {
  95             const { pendingAliasID: PendingAliasID, aliasEmail: name } = alias;
  96
  97             const item = itemBuilder('alias');
  98             item.set('metadata', (metadata) => metadata.merge({ name }));
  99             const content = serializeItemContent(item.data);
 100             const aliasItem = await PassCrypto.createItem({ shareId, content });
 101
 102             return { PendingAliasID, Item: aliasItem };
 103         })
 104     );
 105
 106     const aliases = await Promise.all(
 107         chunk(encryptedItems, MAX_BATCH_PER_REQUEST).map(
 108             async (Items) =>
 109                 (
 110                     await api({
 111                         url: `pass/v1/alias_sync/share/${shareId}/create`,
 112                         method: 'post',
 113                         data: { Items },
 114                     })
 115                 ).Revisions?.RevisionsData!
 116         )
 117     );
 118
 119     return aliases.flat();
 120 };
 121
 122 export const toggleAliasStatus = async ({ shareId, itemId, enabled }: AliasToggleStatusDTO) =>
 123     (
 124         await api({
 125             url: `pass/v1/share/${shareId}/alias/${itemId}/status`,
 126             method: 'put',
 127             data: { Enable: enabled },
 128         })
 129     ).Item;