orgnote-api 0.17.0 → 0.17.2

package/dist/encryption/__tests__/note-encryption.spec.js

@@ -0,0 +1,364 @@
+import { expect, test } from 'vitest';
+import { decryptNote, encryptNote } from '../note-encryption';
+import { armoredPublicKey, armoredPrivateKey, privateKeyPassphrase, } from './encryption-keys';
+import { ModelsPublicNoteEncryptionTypeEnum } from '../../remote-api';
+test('Should encrypt note content via password', async () => {
+    const noteText = `#+ID: qweqwe
+
+#+TITLE: Hello worlld
+
+* Hello?`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+        author: {
+            id: '1',
+            name: 'John Doe',
+            email: 'test@mail.com',
+        },
+    };
+    const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+        format: 'armored',
+    });
+    expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(true);
+    expect(encryptedNote).toMatchSnapshot();
+});
+test('Should encrypt note content via password to binary format', async () => {
+    const noteText = `#+ID: qweqwe
+
+#+TITLE: Hello worlld
+
+* Hello?`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+        author: {
+            id: '1',
+            name: 'John Doe',
+            email: 'test@mail.com',
+        },
+    };
+    const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+        format: 'binary',
+    });
+    expect(encryptedNote).toMatchSnapshot();
+    expect(encryptedNoteText).toBeInstanceOf(Uint8Array);
+});
+test('Should decrypt note content via password', async () => {
+    const noteText = `-----BEGIN PGP MESSAGE-----
+
+wy4ECQMI/CCaKMJEqy/gyROJeRgW9I738dDFBltFlxIjhxrN7nQ6gkX4GgX6
+zt3v0mABvaBJA7corlU8su21TpPApOs/+DMWpVlbI3Zer7QfQK1fSBoSTbCR
+2k3g68Afayke2nLkDNkH62tdOPiTkx7bSlp1zL4uU440IM1g6dC72JkmtoTJ
+5Bjlwt4ZhxFsh+c=
+=csID
+-----END PGP MESSAGE-----`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+    };
+    const decryptedNote = await decryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+    });
+    expect(decryptedNote).toMatchSnapshot();
+});
+test('Should encrypt note via keys', async () => {
+    const noteText = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title for encryption via keys',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+        author: {
+            id: '1',
+            name: 'John Doe',
+            email: 'test@mail.com',
+        },
+    };
+    const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
+        publicKey: armoredPublicKey,
+        privateKey: armoredPrivateKey,
+        privateKeyPassphrase,
+        format: 'armored',
+    });
+    expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(true);
+    expect(encryptedNote).toMatchSnapshot();
+});
+test('Should decrypt note via provided keys', async () => {
+    const encryptedNoteText = `-----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 note = {
+        id: 'id',
+        meta: {
+            title: 'My note title for decryption via keys',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+    };
+    const decryptedNote = await decryptNote(note, {
+        content: encryptedNoteText,
+        type: 'gpgKeys',
+        publicKey: armoredPublicKey,
+        privateKey: armoredPrivateKey,
+        privateKeyPassphrase,
+    });
+    expect(decryptedNote).toMatchSnapshot();
+});
+test('Should not encrypt public note', async () => {
+    const noteText = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title',
+            images: [],
+            published: true,
+            description: 'Awesome description',
+        },
+        author: {
+            id: '1',
+            name: 'John Doe',
+            email: 'test@mail.com',
+        },
+    };
+    const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+        format: 'armored',
+    });
+    expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(false);
+    expect(encryptedNote).toMatchSnapshot();
+});
+test('Should encrypt note with empty encrypted property', async () => {
+    const noteText = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+        author: {
+            id: '1',
+            name: 'John Doe',
+            email: 'test@mail.com',
+        },
+    };
+    const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+        format: 'armored',
+    });
+    expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(true);
+    expect(encryptedNote).toMatchSnapshot();
+});
+test('Should not decrypt note without provided encrypted type', async () => {
+    const noteText = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+        encrypted: undefined,
+        author: {
+            id: '1',
+            name: 'John Doe',
+            email: 'test@mail.com',
+        },
+    };
+    const decryptedInfo = await decryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+    });
+    expect(decryptedInfo).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 = {
+        id: 'id',
+        meta: { ...meta },
+    };
+    const noteText = `#+TITLE: My note title
+#+DESCRIPTION: Awesome description
+#+PUBLISHED: false
+#+FILETAGS: :tag1:tag2:
+
+[[./image1.png]]
+
+Hello world`;
+    const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+    });
+    const [decryptedNote, decryptedNoteText] = await decryptNote(encryptedNote, {
+        content: encryptedNoteText,
+        type: 'gpgPassword',
+        password: '123',
+    });
+    expect(decryptedNote.meta).toEqual(meta);
+    expect(decryptedNoteText).toEqual(noteText);
+});
+test('Should set not encrypted status when params type does not provided', async () => {
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title for decryption via keys',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+    };
+    const noteText = `-----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, {
+        content: noteText,
+        type: 'disabled',
+    });
+    expect(decryptedNote).toMatchSnapshot();
+});
+test('Should encrypt note to binary format', async () => {
+    const noteText = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+    const note = {
+        id: 'id',
+        meta: {
+            title: 'My note title',
+            images: [],
+            published: false,
+            description: 'Awesome description',
+        },
+        author: {
+            id: '1',
+            name: 'John Doe',
+            email: 'test@mail.com',
+        },
+    };
+    const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: 'gpgPassword',
+        password: '123',
+        format: 'binary',
+    });
+    expect(encryptedNoteText).toBeInstanceOf(Uint8Array);
+    expect(encryptedNote).toMatchSnapshot();
+    const [_, decryptedNoteText] = await decryptNote(encryptedNote, {
+        content: encryptedNoteText,
+        type: 'gpgPassword',
+        password: '123',
+    });
+    expect(decryptedNoteText).toEqual(noteText);
+});

package/dist/encryption/encryption.d.ts

@@ -0,0 +1,27 @@
+import { Stream } from 'openpgp';
+import { OrgNoteEncryption, OrgNotePasswordEncryption, WithDecryptionContent } from '../models/encryption';
+import { OrgNoteGpgEncryption, WithEncryptionContent } from '../models';
+import { enums } from 'openpgp';
+export declare class IncorrectOrMissingPrivateKeyPasswordError extends Error {
+}
+export declare class ImpossibleToDecryptWithProvidedKeysError extends Error {
+}
+export declare class IncorrectEncryptionPasswordError extends Error {
+}
+export declare class NoKeysProvidedError extends Error {
+}
+export declare class NoPasswordProvidedError extends Error {
+}
+export declare const encryptViaKeys: <T extends WithEncryptionContent<OrgNoteGpgEncryption>>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
+export declare const encryptViaPassword: <T extends WithEncryptionContent<OrgNotePasswordEncryption>>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
+export declare const decryptViaPassword: <T extends Omit<WithDecryptionContent<OrgNotePasswordEncryption>, "type">>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
+export declare const decryptViaKeys: <T extends Omit<WithDecryptionContent<OrgNoteGpgEncryption>, "type">>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
+export declare const encrypt: <T extends WithEncryptionContent<OrgNoteEncryption>>(encryptionParams: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
+export declare const decrypt: <T extends WithDecryptionContent<OrgNoteEncryption>>(decryptionParams: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
+export declare function _encryptViaKeys<T extends WithEncryptionContent<OrgNoteGpgEncryption>>({ content, publicKey: armoredPublicKey, privateKey: armoredPrivateKey, privateKeyPassphrase, format, }: T): Promise<T['format'] extends 'binary' ? Uint8Array : string>;
+export declare function armor(data: Uint8Array): string;
+export declare function unarmor(data: string): Promise<{
+    text: string;
+    data: Stream<Uint8Array>;
+    type: enums.armor;
+}>;

package/dist/encryption/encryption.js

@@ -0,0 +1,156 @@
+import { createMessage, decrypt as _decrypt, decryptKey, encrypt as _encrypt, readKey, readMessage, readPrivateKey, } from 'openpgp';
+import { ModelsPublicNoteEncryptionTypeEnum } from '../remote-api';
+import { armor as _armor, unarmor as _unarmor, enums } 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);
+export const encrypt = async (encryptionParams) => {
+    if (!encryptionParams.type ||
+        encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled) {
+        return encryptionParams.content;
+    }
+    const res = (encryptionParams.type ===
+        ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+        ? await encryptViaKeys(encryptionParams)
+        : await encryptViaPassword(encryptionParams));
+    return res;
+};
+export const decrypt = async (decryptionParams) => {
+    if (!decryptionParams.type ||
+        decryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled) {
+        return decryptionParams.content;
+    }
+    const decryptedNote = (decryptionParams.type ===
+        ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+        ? await decryptViaKeys(decryptionParams)
+        : await decryptViaPassword(decryptionParams));
+    return decryptedNote;
+};
+async function _encryptViaPassword({ content, password, format = 'binary', }) {
+    const message = await createMessage({
+        text: content,
+    });
+    const encryptedMessage = await _encrypt({
+        message,
+        format: format,
+        passwords: [password],
+    });
+    return encryptedMessage;
+}
+export async function _encryptViaKeys({ content, publicKey: armoredPublicKey, privateKey: armoredPrivateKey, privateKeyPassphrase, format = 'binary', }) {
+    const publicKey = await readKey({ armoredKey: armoredPublicKey });
+    const message = await createMessage({
+        text: content,
+    });
+    const encryptedPrivateKey = await readPrivateKey({
+        armoredKey: armoredPrivateKey,
+    });
+    const privateKey = privateKeyPassphrase
+        ? await decryptKey({
+            privateKey: encryptedPrivateKey,
+            passphrase: privateKeyPassphrase,
+        })
+        : encryptedPrivateKey;
+    const encryptedMessage = await _encrypt({
+        message,
+        format: format,
+        encryptionKeys: publicKey,
+        signingKeys: privateKey,
+    });
+    return encryptedMessage;
+}
+async function _decryptViaPassword({ content, password, format = 'utf8', }) {
+    const isArmoredContent = typeof content === 'string';
+    const message = await (isArmoredContent
+        ? readMessage({ armoredMessage: content })
+        : readMessage({ binaryMessage: content }));
+    const { data: decryptedText } = await _decrypt({
+        message,
+        format,
+        passwords: password,
+    });
+    return decryptedText;
+}
+// TODO: master OrgNoteGpgDecryption type
+async function _decryptViaKeys({ privateKey: armoredPrivateKey, privateKeyPassphrase, content, format = 'utf8', }) {
+    const encryptedPrivateKey = await readPrivateKey({
+        armoredKey: armoredPrivateKey,
+    });
+    const privateKey = privateKeyPassphrase
+        ? await decryptKey({
+            privateKey: encryptedPrivateKey,
+            passphrase: privateKeyPassphrase,
+        })
+        : encryptedPrivateKey;
+    const isString = typeof content === 'string';
+    const message = await (isString
+        ? readMessage({ armoredMessage: content })
+        : readMessage({ binaryMessage: content }));
+    const { data: decryptedText } = await _decrypt({
+        message,
+        format,
+        decryptionKeys: privateKey,
+    });
+    return decryptedText;
+}
+function withCustomErrors(fn) {
+    return async (...args) => {
+        try {
+            return await fn(...args);
+        }
+        catch (e) {
+            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;
+        }
+    };
+}
+// TODO: feat/native-encryption-support add custom error handling
+export function armor(data) {
+    return _armor(enums.armor.message, data);
+}
+export async function unarmor(data) {
+    return await _unarmor(data);
+}

package/dist/encryption/index.js

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

package/dist/encryption/note-encryption.d.ts

@@ -0,0 +1,12 @@
+import { OrgNoteEncryption, WithEncryptionContent, WithNoteDecryptionContent } from '../models/encryption';
+export interface AbstractEncryptedNote {
+    encrypted?: boolean;
+    meta: {
+        [key: string]: any;
+        published?: boolean;
+    };
+}
+export type EncryptionResult<T> = Promise<[T, string]>;
+export type DecryptionResult<T> = Promise<[T, string | Uint8Array]>;
+export declare function encryptNote<T extends AbstractEncryptedNote>(note: T, encryptionParams: WithEncryptionContent<OrgNoteEncryption>): EncryptionResult<T>;
+export declare function decryptNote<T extends AbstractEncryptedNote>(note: T, encryptionParams: WithNoteDecryptionContent<OrgNoteEncryption>): DecryptionResult<T>;

package/dist/encryption/note-encryption.js

@@ -0,0 +1,42 @@
+import { ModelsPublicNoteEncryptionTypeEnum } from '../remote-api';
+import { decrypt, encrypt } from './encryption';
+import { parse, withMetaInfo } from 'org-mode-ast';
+import { isGpgEncrypted } from '..';
+// TODO: master change signature for encrypt notes without content
+export async function encryptNote(note, encryptionParams) {
+    note.encrypted = false;
+    if (!encryptionParams.type ||
+        encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
+        note.meta.published) {
+        return [note, encryptionParams.content];
+    }
+    note.meta = { id: note.meta.id, published: note.meta.published };
+    const encryptedContent = await encrypt(encryptionParams);
+    const encryptedNote = { ...note, encrypted: true };
+    return [encryptedNote, encryptedContent];
+}
+export async function decryptNote(note, encryptionParams) {
+    const isContentEncrypted = isGpgEncrypted(encryptionParams.content);
+    if (note.meta.published ||
+        !encryptionParams.type ||
+        encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
+        !isContentEncrypted) {
+        note.encrypted = isContentEncrypted;
+        return [note, encryptionParams.content];
+    }
+    note.encrypted = true;
+    const decryptionParams = {
+        ...encryptionParams,
+        format: 'utf8',
+    };
+    const decryptedNoteText = await decrypt(decryptionParams);
+    const parsed = withMetaInfo(parse(decryptedNoteText));
+    return [
+        {
+            ...note,
+            encrypted: false,
+            meta: parsed.meta,
+        },
+        decryptedNoteText,
+    ];
+}

package/dist/files-api.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Axios } from 'axios';
+import { Stream } from 'stream';
+export declare const initFilesApi: (axiosInstance: Axios) => {
+    readonly uploadFile: (file: File) => Promise<any>;
+    readonly downloadFile: (relativeFilePath: string) => Promise<Stream>;
+};

package/dist/files-api.js

@@ -0,0 +1,22 @@
+// NOTE: patch cause of incorrect generated api (form-data and swaggo)
+export const initFilesApi = (axiosInstance) => {
+    return {
+        uploadFile: async (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) => {
+            const downloadedFilePath = `/media/${relativeFilePath}`;
+            const stream = await axiosInstance
+                .get(downloadedFilePath, { responseType: 'stream' })
+                .then((r) => r.data);
+            return stream;
+        },
+    };
+};

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './models';
+export * from './encryption';
+export * from './tools';
+export * from './files-api';

package/dist/models/command.d.ts

@@ -0,0 +1,29 @@
+import { DefaultCommands } from './default-commands';
+export declare const DEFAULT_KEYBINDING_GROUP = "default";
+export type CommandGroup = 'settings' | 'editor' | 'global' | 'note-detail' | 'completion' | string;
+export interface CommandHandlerParams<T = any> {
+    event?: KeyboardEvent;
+    data?: T;
+    [key: string]: unknown;
+}
+export interface CommandPreview {
+    description?: string;
+    command?: DefaultCommands | string;
+    title?: string | (() => string);
+    icon?: string | (() => string);
+}
+export interface CommandMeta<T = any> extends Partial<CommandPreview> {
+    keySequence?: string | string[];
+    group?: CommandGroup;
+    allowOnInput?: boolean;
+    ignorePrompt?: boolean;
+    interactive?: boolean;
+    system?: boolean;
+    available?: () => boolean;
+    context?: {
+        [key: string]: T;
+    };
+}
+export interface Command<T = any> extends CommandMeta<T> {
+    handler: (params?: CommandHandlerParams) => unknown | Promise<unknown>;
+}

package/dist/models/command.js

@@ -0,0 +1 @@
+export const DEFAULT_KEYBINDING_GROUP = 'default';