orgnote-api 0.20.2 → 0.40.9

package/encryption/__tests__/encryption.spec.js

@@ -1,10 +1,10 @@
 import { encryptViaKeys, decryptViaKeys, encryptViaPassword, decryptViaPassword, NoKeysProvidedError, NoPasswordProvidedError, IncorrectOrMissingPrivateKeyPasswordError, encrypt, decrypt, armor, unarmor, ImpossibleToDecryptWithProvidedKeysError, } from "../encryption.js";
 import { test, expect } from 'vitest';
 import { armoredPublicKey, armoredPrivateKey, privateKeyPassphrase, } from "./encryption-keys.js";
-import { ModelsPublicNoteEncryptionTypeEnum } from "../../remote-api/index.js";
+import { EncryptionType } from "../../models/encryption.js";
 test('Should encrypt text as armored message via keys', async () => {
     const res = await encryptViaKeys({
-        type: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
+        type: EncryptionType.GpgKeys,
         content: 'Hello world',
         publicKey: armoredPublicKey,
         privateKey: armoredPrivateKey,
@@ -15,7 +15,7 @@ test('Should encrypt text as armored message via keys', async () => {
 });
 test('Should encrypt text via keys', async () => {
     const res = await encryptViaKeys({
-        type: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
+        type: EncryptionType.GpgKeys,
         content: 'Hello world',
         publicKey: armoredPublicKey,
         privateKey: armoredPrivateKey,
@@ -66,7 +66,7 @@ YQ==
 test('Should encrypt via password', async () => {
     const password = 'test';
     const res = await encryptViaPassword({
-        type: ModelsPublicNoteEncryptionTypeEnum.GpgPassword,
+        type: EncryptionType.GpgPassword,
         content: 'Hello world',
         password,
         format: 'armored',
@@ -262,7 +262,6 @@ test('Should armor and unarmor encrypted file', async () => {
     "-----BEGIN PGP MESSAGE-----
 
     SGVsbG8gd29ybGQ=
-    =7asC
     -----END PGP MESSAGE-----
     "
   `);

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

@@ -1,112 +1,48 @@
-import { expect, test } from 'vitest';
+import { beforeEach, expect, test } from 'vitest';
 import { decryptNote, encryptNote } from "../note-encryption.js";
 import { armoredPublicKey, armoredPrivateKey, privateKeyPassphrase, } from "./encryption-keys.js";
-import { ModelsPublicNoteEncryptionTypeEnum } from "../../remote-api/index.js";
-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();
+import { EncryptionType } from "../../models/encryption.js";
+import { faker } from '@faker-js/faker';
+beforeEach(() => {
+    faker.seed(1);
+    faker.setDefaultRefDate(new Date('2024-01-01T00:00:00.000Z'));
 });
-test('Should encrypt note content via password to binary format', async () => {
-    const noteText = `#+ID: qweqwe
-
-#+TITLE: Hello worlld
-
-* Hello?`;
-    const note = {
-        id: 'id',
+function generateNoteInfo(overrides = {}) {
+    return {
+        id: faker.string.uuid(),
         meta: {
-            title: 'My note title',
-            images: [],
-            published: false,
-            description: 'Awesome description',
-        },
-        author: {
-            id: '1',
-            name: 'John Doe',
-            email: 'test@mail.com',
-        },
+            title: faker.lorem.sentence(),
+            images: faker.helpers.uniqueArray(() => faker.image.url(), 3),
+            published: faker.datatype.boolean(),
+            description: faker.lorem.paragraph(),
+        },
+        createdAt: faker.date.past().toISOString(),
+        updatedAt: faker.date.recent().toISOString(),
+        touchedAt: faker.date.recent().toISOString(),
+        deletedAt: faker.datatype.boolean()
+            ? faker.date.recent().toISOString()
+            : undefined,
+        filePath: faker.helpers.uniqueArray(() => faker.system.filePath(), 2),
+        isMy: faker.datatype.boolean(),
+        author: faker.datatype.boolean()
+            ? {
+                id: faker.string.uuid(),
+                name: faker.person.fullName(),
+                email: faker.internet.email(),
+            }
+            : undefined,
+        bookmarked: faker.datatype.boolean(),
+        encrypted: faker.datatype.boolean(),
+        ...overrides,
     };
-    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 noteText = '#+title: Test note\n\nBody text';
+    const note = generateNoteInfo();
+    note.meta.published = false;
     const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
         content: noteText,
-        type: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
+        type: EncryptionType.GpgKeys,
         publicKey: armoredPublicKey,
         privateKey: armoredPrivateKey,
         privateKeyPassphrase,
@@ -115,251 +51,24 @@ test('Should encrypt note via keys', async () => {
     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',
+test('Should decrypt note via keys', async () => {
+    const noteText = '#+title: Test note\n\nBody text';
+    const note = generateNoteInfo();
+    note.meta.published = false;
+    const [, encryptedNoteText] = await encryptNote(note, {
+        content: noteText,
+        type: EncryptionType.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();
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, decryptedNoteText] = await decryptNote(encryptedNote, {
         content: encryptedNoteText,
-        type: 'gpgPassword',
-        password: '123',
+        type: EncryptionType.GpgKeys,
+        publicKey: armoredPublicKey,
+        privateKey: armoredPrivateKey,
+        privateKeyPassphrase,
     });
-    expect(decryptedNoteText).toEqual(noteText);
+    expect(decryptedNote).toMatchSnapshot();
 });

package/encryption/encryption.d.ts

@@ -3,19 +3,24 @@ import { OrgNoteEncryption, OrgNotePasswordEncryption, WithDecryptionContent } f
 import { OrgNoteGpgEncryption, WithEncryptionContent } from '../models/index.js';
 import { enums } from 'openpgp';
 export declare class IncorrectOrMissingPrivateKeyPasswordError extends Error {
+    constructor(message?: string);
 }
 export declare class ImpossibleToDecryptWithProvidedKeysError extends Error {
+    constructor(message?: string);
 }
 export declare class IncorrectEncryptionPasswordError extends Error {
+    constructor(message?: string);
 }
 export declare class NoKeysProvidedError extends Error {
+    constructor(message?: string);
 }
 export declare class NoPasswordProvidedError extends Error {
+    constructor(message?: string);
 }
-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 encryptViaKeys: <T extends WithEncryptionContent<OrgNoteGpgEncryption>>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array<ArrayBufferLike> : string>;
+export declare const encryptViaPassword: <T extends WithEncryptionContent<OrgNotePasswordEncryption>>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array<ArrayBufferLike> : string>;
+export declare const decryptViaPassword: <T extends Omit<WithDecryptionContent<OrgNotePasswordEncryption>, "type">>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array<ArrayBufferLike> : string>;
+export declare const decryptViaKeys: <T extends Omit<WithDecryptionContent<OrgNoteGpgEncryption>, "type">>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array<ArrayBufferLike> : 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>;

package/encryption/encryption.js

@@ -1,15 +1,35 @@
 import { createMessage, decrypt as _decrypt, decryptKey, encrypt as _encrypt, readKey, readMessage, readPrivateKey, } from 'openpgp';
-import { ModelsPublicNoteEncryptionTypeEnum } from "../remote-api/index.js";
+import { EncryptionType, } from "../models/encryption.js";
 import { armor as _armor, unarmor as _unarmor, enums } from 'openpgp';
 export class IncorrectOrMissingPrivateKeyPasswordError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'IncorrectOrMissingPrivateKeyPasswordError';
+    }
 }
 export class ImpossibleToDecryptWithProvidedKeysError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ImpossibleToDecryptWithProvidedKeysError';
+    }
 }
 export class IncorrectEncryptionPasswordError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'IncorrectEncryptionPasswordError';
+    }
 }
 export class NoKeysProvidedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NoKeysProvidedError';
+    }
 }
 export class NoPasswordProvidedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NoPasswordProvidedError';
+    }
 }
 const noPrivateKeyPassphraseProvidedErrorMsg = 'Error: Signing key is not decrypted.';
 const incorrectPrivateKeyPassphraseErrorMsg = 'Error decrypting private key: Incorrect key passphrase';
@@ -26,24 +46,24 @@ export const decryptViaPassword = withCustomErrors(_decryptViaPassword);
 export const decryptViaKeys = withCustomErrors(_decryptViaKeys);
 export const encrypt = async (encryptionParams) => {
     if (!encryptionParams.type ||
-        encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled) {
+        encryptionParams.type === EncryptionType.Disabled) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return encryptionParams.content;
     }
     const res = (encryptionParams.type ===
-        ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+        EncryptionType.GpgKeys
         ? await encryptViaKeys(encryptionParams)
         : await encryptViaPassword(encryptionParams));
     return res;
 };
 export const decrypt = async (decryptionParams) => {
     if (!decryptionParams.type ||
-        decryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled) {
+        decryptionParams.type === EncryptionType.Disabled) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return decryptionParams.content;
     }
     const decryptedNote = (decryptionParams.type ===
-        ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+        EncryptionType.GpgKeys
         ? await decryptViaKeys(decryptionParams)
         : await decryptViaPassword(decryptionParams));
     return decryptedNote;

package/encryption/note-encryption.d.ts

@@ -1,7 +1,7 @@
 import { OrgNoteEncryption, WithEncryptionContent, WithNoteDecryptionContent } from '../models/encryption.js';
 export interface AbstractEncryptedNote {
     encrypted?: boolean;
-    meta: {
+    meta?: {
         [key: string]: any;
         published?: boolean;
     };

package/encryption/note-encryption.js

@@ -1,25 +1,25 @@
-import { ModelsPublicNoteEncryptionTypeEnum } from "../remote-api/index.js";
 import { decrypt, encrypt } from "./encryption.js";
+import { EncryptionType } from "../models/encryption.js";
 import { parse, withMetaInfo } from 'org-mode-ast';
 import { isGpgEncrypted } from '../index.js';
 // 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) {
+        encryptionParams.type === EncryptionType.Disabled ||
+        note.meta?.published) {
         return [note, encryptionParams.content];
     }
-    note.meta = { id: note.meta.id, published: note.meta.published };
+    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 ||
+    if (note.meta?.published ||
         !encryptionParams.type ||
-        encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
+        encryptionParams.type === EncryptionType.Disabled ||
         !isContentEncrypted) {
         note.encrypted = isContentEncrypted;
         return [note, encryptionParams.content];

package/files-api.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Axios } from 'axios';
 import { Stream } from 'stream';
 export declare const initFilesApi: (axiosInstance: Axios) => {

package/index.d.ts

@@ -2,8 +2,11 @@ export * from './api.js';
 export * from './models/index.js';
 import type * as ast from 'org-mode-ast';
 export * from './encryption/index.js';
-export * from './tools/index.js';
+export * from './utils/index.js';
 export * from './files-api.js';
 export * from './mappers/index.js';
 export * from './constants/index.js';
+export * from './utils/with-root.js';
+export * from './sync/index.js';
 export { ast };
+export * from './websocket/client.js';

package/index.js

@@ -1,7 +1,10 @@
 export * from "./api.js";
 export * from "./models/index.js";
 export * from "./encryption/index.js";
-export * from "./tools/index.js";
+export * from "./utils/index.js";
 export * from "./files-api.js";
 export * from "./mappers/index.js";
 export * from "./constants/index.js";
+export * from "./utils/with-root.js";
+export * from "./sync/index.js";
+export * from "./websocket/client.js";

package/mappers/orgnode-to-note.d.ts

@@ -1,3 +1,3 @@
 import { OrgNode } from 'org-mode-ast';
-import { FileInfo, Note } from "../models/index.js";
-export declare function orgnodeToNote(orgnode: OrgNode, fileInfo: FileInfo): Note;
+import { DiskFile, NoteInfo } from "../models/index.js";
+export declare function orgnodeToNoteInfo(orgnode: OrgNode, fileInfo: DiskFile, isMy?: boolean): NoteInfo;

package/mappers/orgnode-to-note.js

@@ -1,7 +1,8 @@
-import { splitPath } from "../tools/index.js";
-export function orgnodeToNote(orgnode, fileInfo) {
+import { splitPath } from "../utils/index.js";
+export function orgnodeToNoteInfo(orgnode, fileInfo, isMy) {
     return {
         id: orgnode.meta.id,
+        isMy,
         meta: orgnode.meta,
         filePath: splitPath(fileInfo.path),
         touchedAt: fileInfo.atime && new Date(fileInfo.atime).toISOString(),

package/models/auth-state.d.ts

@@ -0,0 +1,9 @@
+import { type InferOutput } from 'valibot';
+export declare const AUTH_ENVIRONMENTS: readonly ["web", "mobile", "electron", "desktop"];
+export type AuthEnvironment = (typeof AUTH_ENVIRONMENTS)[number];
+export declare const AUTH_ENVIRONMENT_SCHEMA: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"web", undefined>, import("valibot").LiteralSchema<"mobile", undefined>, import("valibot").LiteralSchema<"electron", undefined>, import("valibot").LiteralSchema<"desktop", undefined>], undefined>;
+export declare const AUTH_STATE_SCHEMA: import("valibot").ObjectSchema<{
+    readonly environment: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"web", undefined>, import("valibot").LiteralSchema<"mobile", undefined>, import("valibot").LiteralSchema<"electron", undefined>, import("valibot").LiteralSchema<"desktop", undefined>], undefined>;
+    readonly redirectUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type AuthState = InferOutput<typeof AUTH_STATE_SCHEMA>;

package/models/auth-state.js

@@ -0,0 +1,12 @@
+import { literal, object, optional, string, union, } from 'valibot';
+export const AUTH_ENVIRONMENTS = ['web', 'mobile', 'electron', 'desktop'];
+export const AUTH_ENVIRONMENT_SCHEMA = union([
+    literal('web'),
+    literal('mobile'),
+    literal('electron'),
+    literal('desktop'),
+]);
+export const AUTH_STATE_SCHEMA = object({
+    environment: AUTH_ENVIRONMENT_SCHEMA,
+    redirectUrl: optional(string()),
+});