orgnote-api 0.12.2 → 0.12.3

package/encryption/__tests__/note-encryption.spec.ts

@@ -0,0 +1,346 @@
+import { expect, test } from 'vitest';
+import { decryptNote, encryptNote } from '../note-encryption';
+import { Note } from '../../models';
+import {
+  armoredPublicKey,
+  armoredPrivateKey,
+  privateKeyPassphrase,
+} from './encryption-keys';
+
+test('Should encrypt note content via password', async () => {
+  const content = `#+ID: qweqwe
+
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    encryptionType: 'gpgPassword',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    true
+  );
+  delete encryptedNote.content;
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should decrypt note content via password', async () => {
+  const note: Note = {
+    id: 'id',
+    encryptionType: 'gpgPassword',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content: `-----BEGIN PGP MESSAGE-----
+
+wy4ECQMI/CCaKMJEqy/gyROJeRgW9I738dDFBltFlxIjhxrN7nQ6gkX4GgX6
+zt3v0mABvaBJA7corlU8su21TpPApOs/+DMWpVlbI3Zer7QfQK1fSBoSTbCR
+2k3g68Afayke2nLkDNkH62tdOPiTkx7bSlp1zL4uU440IM1g6dC72JkmtoTJ
+5Bjlwt4ZhxFsh+c=
+=csID
+-----END PGP MESSAGE-----`,
+  };
+
+  const decryptedNote = await decryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(decryptedNote).toMatchSnapshot();
+});
+
+test('Should encrypt note via keys', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    encryptionType: 'gpgKeys',
+    meta: {
+      title: 'My note title for encryption via keys',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgKeys',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    true
+  );
+  delete encryptedNote.content;
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should decrypt note via provided keys', async () => {
+  const note: Note = {
+    id: 'id',
+    encryptionType: 'gpgKeys',
+    meta: {
+      title: 'My note title for decryption via keys',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content: `-----BEGIN PGP MESSAGE-----
+
+wcFMA/vryg+TTn0rAQ//TBFRjKmjRQoLhSrgeH+NbsZXbxvo7Ey4k+BQ9XA5
++CMpXH9uFUxsSaI5+McUSEt32VI17HRpXQDCL9nwaWqWOanMaRe0tXXhtox2
+gfe2f/6zsge9ux+mXF2BG4z+V5T8XIOrfzxosVprdJHZHM3x7cW5USQ0t2i2
+FiOUWxSZO1899J3yICpMvhDXvTLVZuKpSNQho5PyXSeZa83eN+uYkhgt9lsk
+0KW88Nr435S6n6mVw/zpitXIgEKpkqh46mhG+1W3aC0lYx6j9lHm3bjtdb4r
+2mtZbWKwfdBggEy8qEeiUeslvKd6uWtEccomzFgJkaqWVGknLmrBdHfztRIV
+fbZhxHz+J3GFOIgXf/5+fv+zg0nTazgz1mDUfnTHw3+qcAyEJ0ADdyg9EZc+
+bKbK0GwzMDPQeM+cCRDWUTiIa1ruyEETiwMdhWUDztF8XxY2o8jXPerZ0NhG
+R8l+SvAdYQQXPfxEh9lA3thkyz/Vp72pW46lUeJHGSq/fS6KIdLHLP9Z2e1J
+aCFpNMgyAN+BaXwnbLZfz6k5hV8awbRScSWQLEg69D9b287SFDPOYW7OZikn
+CKXL7xyQ5LrWJZN9Z/UPGjy+PdEw1SBhyluW6DQ+Sz1j4K8USTLqY89EInDl
+G7AxHGujR9UkUGyUvvc71XW7jEOogiDgn1ZMoj9Y58LSweUB8vfkY3VF84Fy
+zGVvLFWnFbtnWuoQC4OOXv1F6ETdmEsSMEMWKzRLDGPyqNX7FhG3cejlEuiK
+EsT5oQhz00RECmnR8mJkGmJhzWmmeoQvaucFqhTOZjvYl9ivuEMBZ2jtkdHn
+R6UNcNZRpCbfnl7YoikqbGBgqDFYydFGHXKHDpYhcQYWJsMDUayzUiPtzmaE
+tgfTgNNqgPxkLnWA99KYNU8DH+FwgaYBuw9dwdqwcjxSbZjHhCFGUfsqM+ik
+O9gcoAwVO1usODlESU7OWuSF2tIv5DBG5rhlSyxBp4d4aWmaumTswAdojy2O
+sM70ETbg0mC8niW9lNsgJp55oFmlksvzjUIit5rBEr55rtPcJSgakPpR2yvd
+Q4XjybUmV0IdONMhk/OlqaBPtnA0RG+qTcm7oP1qH/m5zRA0ZplVQ5ylkQwr
+LwGq5JQpJkgxxgLIrUbbtzYBShXSr5c1XXR0LIRiNgtb6s1s4mt+fbyExdJF
++ceuu+/xYrW/YTuEJpHxLiZ+aNPW5g5Y7Hbqu3hp3UL/kD44cc8JjZh18spX
+p/ncojDhF2r2vhR+CndYcMkpGMV+t1pGKC8wlcFc7lb9GJASnqMGvhQmvIaG
+gO/x7UjuTZSBW+kITHHZJDqYryKUv1j0CkHxIn9tWsYOpa1giOFtXX5v0AAM
+AJR/s/beLlqwCsUdYnw1TkP/0u0ZK3RPio1nJ7S6ckPfsM7DqCWD8ILD8Cdr
+cuzQrWaE30t5PXx53xBPO+6t5wKfDL35WHWG1Irmvz9UuT7tDS3IzwtF4ijF
+PX6alTbxGnoHgZ4bG4J1wfpTNPppP1gJeVg67VqOypzdZi+SjofMWnFgRFmD
+yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
+=LjkG
+-----END PGP MESSAGE-----`,
+  };
+
+  const decryptedNote = await decryptNote(note, {
+    type: 'gpgKeys',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+  });
+
+  expect(decryptedNote).toMatchSnapshot();
+});
+
+test('Should not encrypt public note', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    encryptionType: 'gpgPassword',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: true,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    false
+  );
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should encrypt note with empty encrypted property', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    true
+  );
+
+  delete encryptedNote.content;
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should not decrypt note without provided encrypted type', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+  const note: Note = {
+    id: 'id',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    encrypted: undefined,
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const decryptedNote = await decryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(decryptedNote).toMatchSnapshot();
+});
+
+test('Should decrypt note and note meta', async () => {
+  const meta = {
+    title: 'My note title',
+    images: ['./image1.png'],
+    published: false,
+    description: 'Awesome description',
+    fileTags: ['tag1', 'tag2'],
+  };
+  const note: Note = {
+    id: 'id',
+    meta: { ...meta },
+    encryptionType: 'gpgPassword',
+    content: `#+TITLE: My note title
+#+DESCRIPTION: Awesome description
+#+PUBLISHED: false
+#+FILETAGS: :tag1:tag2:
+
+[[./image1.png]]
+
+Hello world`,
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  const decryptedNote = await decryptNote(encryptedNote, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(meta).toEqual(decryptedNote.meta);
+});
+
+test('Should set not encrypted status when params type does not provided', async () => {
+  const note: Note = {
+    id: 'id',
+    encryptionType: 'gpgKeys',
+    meta: {
+      title: 'My note title for decryption via keys',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content: `-----BEGIN PGP MESSAGE-----
+
+wcFMA/vryg+TTn0rAQ//TBFRjKmjRQoLhSrgeH+NbsZXbxvo7Ey4k+BQ9XA5
++CMpXH9uFUxsSaI5+McUSEt32VI17HRpXQDCL9nwaWqWOanMaRe0tXXhtox2
+gfe2f/6zsge9ux+mXF2BG4z+V5T8XIOrfzxosVprdJHZHM3x7cW5USQ0t2i2
+FiOUWxSZO1899J3yICpMvhDXvTLVZuKpSNQho5PyXSeZa83eN+uYkhgt9lsk
+0KW88Nr435S6n6mVw/zpitXIgEKpkqh46mhG+1W3aC0lYx6j9lHm3bjtdb4r
+2mtZbWKwfdBggEy8qEeiUeslvKd6uWtEccomzFgJkaqWVGknLmrBdHfztRIV
+fbZhxHz+J3GFOIgXf/5+fv+zg0nTazgz1mDUfnTHw3+qcAyEJ0ADdyg9EZc+
+bKbK0GwzMDPQeM+cCRDWUTiIa1ruyEETiwMdhWUDztF8XxY2o8jXPerZ0NhG
+R8l+SvAdYQQXPfxEh9lA3thkyz/Vp72pW46lUeJHGSq/fS6KIdLHLP9Z2e1J
+aCFpNMgyAN+BaXwnbLZfz6k5hV8awbRScSWQLEg69D9b287SFDPOYW7OZikn
+CKXL7xyQ5LrWJZN9Z/UPGjy+PdEw1SBhyluW6DQ+Sz1j4K8USTLqY89EInDl
+G7AxHGujR9UkUGyUvvc71XW7jEOogiDgn1ZMoj9Y58LSweUB8vfkY3VF84Fy
+zGVvLFWnFbtnWuoQC4OOXv1F6ETdmEsSMEMWKzRLDGPyqNX7FhG3cejlEuiK
+EsT5oQhz00RECmnR8mJkGmJhzWmmeoQvaucFqhTOZjvYl9ivuEMBZ2jtkdHn
+R6UNcNZRpCbfnl7YoikqbGBgqDFYydFGHXKHDpYhcQYWJsMDUayzUiPtzmaE
+tgfTgNNqgPxkLnWA99KYNU8DH+FwgaYBuw9dwdqwcjxSbZjHhCFGUfsqM+ik
+O9gcoAwVO1usODlESU7OWuSF2tIv5DBG5rhlSyxBp4d4aWmaumTswAdojy2O
+sM70ETbg0mC8niW9lNsgJp55oFmlksvzjUIit5rBEr55rtPcJSgakPpR2yvd
+Q4XjybUmV0IdONMhk/OlqaBPtnA0RG+qTcm7oP1qH/m5zRA0ZplVQ5ylkQwr
+LwGq5JQpJkgxxgLIrUbbtzYBShXSr5c1XXR0LIRiNgtb6s1s4mt+fbyExdJF
++ceuu+/xYrW/YTuEJpHxLiZ+aNPW5g5Y7Hbqu3hp3UL/kD44cc8JjZh18spX
+p/ncojDhF2r2vhR+CndYcMkpGMV+t1pGKC8wlcFc7lb9GJASnqMGvhQmvIaG
+gO/x7UjuTZSBW+kITHHZJDqYryKUv1j0CkHxIn9tWsYOpa1giOFtXX5v0AAM
+AJR/s/beLlqwCsUdYnw1TkP/0u0ZK3RPio1nJ7S6ckPfsM7DqCWD8ILD8Cdr
+cuzQrWaE30t5PXx53xBPO+6t5wKfDL35WHWG1Irmvz9UuT7tDS3IzwtF4ijF
+PX6alTbxGnoHgZ4bG4J1wfpTNPppP1gJeVg67VqOypzdZi+SjofMWnFgRFmD
+yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
+=LjkG
+-----END PGP MESSAGE-----`,
+  };
+
+  const decryptedNote = await decryptNote(note, {
+    type: 'disabled',
+  });
+
+  expect(decryptedNote).toMatchSnapshot();
+});

package/encryption/encryption.ts

@@ -0,0 +1,172 @@
+import {
+  createMessage,
+  decrypt,
+  decryptKey,
+  encrypt,
+  readKey,
+  readMessage,
+  readPrivateKey,
+} from 'openpgp';
+
+export class IncorrectOrMissingPrivateKeyPasswordError extends Error {}
+export class ImpossibleToDecryptWithProvidedKeysError extends Error {}
+export class IncorrectEncryptionPasswordError extends Error {}
+export class NoKeysProvidedError extends Error {}
+export class NoPasswordProvidedError extends Error {}
+
+const noPrivateKeyPassphraseProvidedErrorMsg =
+  'Error: Signing key is not decrypted.';
+const incorrectPrivateKeyPassphraseErrorMsg =
+  'Error decrypting private key: Incorrect key passphrase';
+const decryptionKeyIsNotDecryptedErrorMsg =
+  'Error decrypting message: Decryption key is not decrypted.';
+const corruptedPrivateKeyErrorMsg = 'Misformed armored text';
+
+const decriptionFailedErrorMsg =
+  'Error decrypting message: Session key decryption failed.';
+const incorrectEncryptionPasswordErrorMsg =
+  'Error decrypting message: Modification detected.';
+
+const noSymmetricallyEncryptedSessionKeyErrorMsg =
+  'Error decrypting message: No symmetrically encrypted session key packet found.';
+
+const armoredTextNotTypePrivateKeyErrorMsg =
+  'Armored text not of type private key';
+
+const notPrivateKeyErrprMsg =
+  'Error decrypting message: No public key encrypted session key packet found.';
+
+export const encryptViaKeys = withCustomErrors(_encryptViaKeys);
+export const encryptViaPassword = withCustomErrors(_encryptViaPassword);
+export const decryptViaPassword = withCustomErrors(_decryptViaPassword);
+export const decryptViaKeys = withCustomErrors(_decryptViaKeys);
+
+async function _encryptViaPassword(
+  text: string,
+  password: string
+): Promise<string> {
+  const message = await createMessage({
+    text,
+  });
+
+  const encryptedMessage = await encrypt({
+    message,
+    format: 'armored',
+    passwords: [password],
+  });
+
+  return encryptedMessage.toString();
+}
+
+async function _encryptViaKeys(
+  text: string,
+  armoredPublicKey: string,
+  armoredPrivateKey: string,
+  privateKeyPassphrase?: string
+): Promise<string> {
+  const publicKey = await readKey({ armoredKey: armoredPublicKey });
+
+  const message = await createMessage({
+    text,
+  });
+
+  const encryptedPrivateKey = await readPrivateKey({
+    armoredKey: armoredPrivateKey,
+  });
+
+  const privateKey = privateKeyPassphrase
+    ? await decryptKey({
+        privateKey: encryptedPrivateKey,
+        passphrase: privateKeyPassphrase,
+      })
+    : encryptedPrivateKey;
+
+  const encryptedMessage = await encrypt({
+    message,
+    format: 'armored',
+    encryptionKeys: publicKey,
+    signingKeys: privateKey,
+  });
+
+  return encryptedMessage.toString();
+}
+
+async function _decryptViaPassword(
+  data: string,
+  password: string
+): Promise<string> {
+  const message = await readMessage({ armoredMessage: data });
+
+  const { data: decryptedText } = await decrypt({
+    message,
+    passwords: password,
+  });
+
+  return decryptedText.toString();
+}
+
+async function _decryptViaKeys(
+  data: string,
+  armoredPrivateKey: string,
+  privateKeyPassword?: string
+): Promise<string> {
+  const encryptedPrivateKey = await readPrivateKey({
+    armoredKey: armoredPrivateKey,
+  });
+
+  const privateKey = privateKeyPassword
+    ? await decryptKey({
+        privateKey: encryptedPrivateKey,
+        passphrase: privateKeyPassword,
+      })
+    : encryptedPrivateKey;
+
+  const message = await readMessage({ armoredMessage: data });
+
+  const { data: decryptedText } = await decrypt({
+    message,
+    decryptionKeys: privateKey,
+  });
+
+  return decryptedText.toString();
+}
+
+function withCustomErrors<P extends unknown[], T>(
+  fn: (...args: P) => Promise<T | never>
+) {
+  return async (...args: P): Promise<T> => {
+    try {
+      return await fn(...args);
+    } catch (e: unknown) {
+      if (!(e instanceof Error)) {
+        throw e;
+      }
+      if (
+        [
+          noPrivateKeyPassphraseProvidedErrorMsg,
+          incorrectPrivateKeyPassphraseErrorMsg,
+          corruptedPrivateKeyErrorMsg,
+          decryptionKeyIsNotDecryptedErrorMsg,
+          armoredTextNotTypePrivateKeyErrorMsg,
+        ].includes(e.message)
+      ) {
+        throw new IncorrectOrMissingPrivateKeyPasswordError(e.message);
+      }
+      if (e.message === decriptionFailedErrorMsg) {
+        throw new ImpossibleToDecryptWithProvidedKeysError(e.message);
+      }
+      if (e.message === incorrectEncryptionPasswordErrorMsg) {
+        throw new IncorrectEncryptionPasswordError();
+      }
+      if (e.message === noSymmetricallyEncryptedSessionKeyErrorMsg) {
+        throw new NoKeysProvidedError();
+      }
+
+      if (e.message === notPrivateKeyErrprMsg) {
+        throw new NoPasswordProvidedError();
+      }
+
+      throw e;
+    }
+  };
+}

package/encryption/index.ts

@@ -0,0 +1,2 @@
+export * from './note-encryption';
+export * from './encryption';

package/encryption/note-encryption.ts

@@ -0,0 +1,148 @@
+import {
+  ModelsPublicNote,
+  ModelsPublicNoteEncryptionTypeEnum,
+} from '../remote-api';
+
+import {
+  decryptViaKeys,
+  decryptViaPassword,
+  encryptViaKeys,
+  encryptViaPassword,
+} from './encryption';
+import { OrgNoteEncryption } from '../models/encryption';
+import { parse, withMetaInfo } from 'org-mode-ast';
+import { isGpgEncrypted } from '..';
+
+export type NoteEncryptionType = `${ModelsPublicNote['encryptionType']}`;
+
+export interface AbstractEncryptedNote {
+  content: string;
+  encryptionType?: NoteEncryptionType;
+  encrypted?: boolean;
+  meta: {
+    [key: string]: any;
+    published?: boolean;
+  };
+}
+export async function encryptNote<T extends AbstractEncryptedNote>(
+  note: T,
+  encryptionParams: OrgNoteEncryption
+): Promise<T> {
+  note.encrypted = false;
+  if (
+    !encryptionParams.type ||
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
+    note.meta.published
+  ) {
+    return note;
+  }
+
+  note.meta = { id: note.meta.id, published: note.meta.published };
+
+  const encryptedNote =
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+      ? await encryptNoteViaKeys(
+          note,
+          encryptionParams.publicKey,
+          encryptionParams.privateKey,
+          encryptionParams.privateKeyPassphrase
+        )
+      : await encryptNoteViaPassword(note, encryptionParams.password);
+
+  encryptedNote.encrypted = true;
+  return encryptedNote;
+}
+export async function encryptNoteViaPassword<T extends AbstractEncryptedNote>(
+  note: T,
+  password: string
+): Promise<T> {
+  const content = await encryptViaPassword(note.content, password);
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgPassword,
+  };
+}
+
+export async function encryptNoteViaKeys<T extends AbstractEncryptedNote>(
+  note: T,
+  publicKey: string,
+  privateKey: string,
+  privateKeyPassphrase?: string
+): Promise<T> {
+  const content = await encryptViaKeys(
+    note.content,
+    publicKey,
+    privateKey,
+    privateKeyPassphrase
+  );
+
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
+  };
+}
+
+export async function decryptNote<T extends AbstractEncryptedNote>(
+  note: T,
+  encryptionParams: OrgNoteEncryption
+): Promise<T> {
+  const isContentEncrypted = isGpgEncrypted(note.content);
+  if (
+    note.meta.published ||
+    !note.encryptionType ||
+    !encryptionParams.type ||
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
+    !isContentEncrypted
+  ) {
+    note.encrypted = isContentEncrypted;
+    return note;
+  }
+  note.encrypted = true;
+  const decryptedNote =
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+      ? await decryptNoteViaKeys(
+          note,
+          encryptionParams.privateKey,
+          encryptionParams.privateKeyPassphrase
+        )
+      : await decryptNoteViaPassword(note, encryptionParams.password);
+
+  const parsed = withMetaInfo(parse(decryptedNote.content));
+
+  return {
+    ...decryptedNote,
+    encrypted: false,
+    meta: parsed.meta,
+  };
+}
+
+export async function decryptNoteViaPassword<T extends AbstractEncryptedNote>(
+  note: T,
+  password: string
+): Promise<T> {
+  const content = await decryptViaPassword(note.content, password);
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgPassword,
+  };
+}
+
+export async function decryptNoteViaKeys<T extends AbstractEncryptedNote>(
+  note: T,
+  privateKey: string,
+  privateKeyPassphrase?: string
+): Promise<T> {
+  const content = await decryptViaKeys(
+    note.content,
+    privateKey,
+    privateKeyPassphrase
+  );
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
+  };
+}

package/files-api.ts

@@ -0,0 +1,25 @@
+import { Axios } from 'axios';
+import { Stream } from 'stream';
+
+// NOTE: patch cause of incorrect generated api (form-data and swaggo)
+export const initFilesApi = (axiosInstance: Axios) => {
+  return {
+    uploadFile: async (file: File) => {
+      const formData = new FormData();
+      formData.append('files', file);
+      const response = await axiosInstance.post('/files/upload', formData, {
+        headers: {
+          'Content-Type': 'multipart/form-data',
+        },
+      });
+      return response.data;
+    },
+    downloadFile: async (relativeFilePath: string): Promise<Stream> => {
+      const downloadedFilePath = `/media/${relativeFilePath}`;
+      const stream = await axiosInstance
+        .get(downloadedFilePath, { responseType: 'stream' })
+        .then((r) => r.data);
+      return stream;
+    },
+  } as const;
+};

package/index.ts

@@ -0,0 +1,7 @@
+export * from './api';
+export * from './models';
+import type * as ast from 'org-mode-ast';
+export * from './encryption';
+export * from './tools';
+export * from './files-api';
+export { ast };