orgnote-api 0.12.0 → 0.13.0

package/encryption/__tests__/encryption.spec.ts

@@ -6,6 +6,8 @@ import {
   NoKeysProvidedError,
   NoPasswordProvidedError,
   IncorrectOrMissingPrivateKeyPasswordError,
+  encrypt,
+  decrypt,
 } from '../encryption';
 import { test, expect } from 'vitest';
 
@@ -163,3 +165,43 @@ aGW80jwBXEQ7uTjT8akpOKiH7BIuhEUZIXh+vDveG0Uwf63s2dIklznAEo+E
     expect(e).toBeInstanceOf(NoPasswordProvidedError);
   }
 });
+
+test('Should encrypt and decrypt text by provided configs via password', async () => {
+  const text = 'Hello world';
+  const password = '123';
+
+  const res = await encrypt(text, {
+    type: 'gpgPassword',
+    password,
+  });
+
+  expect(res.startsWith('-----BEGIN PGP MESSAGE-----')).toBeTruthy();
+
+  const decryptedMessage = await decrypt(res, {
+    type: 'gpgPassword',
+    password,
+  });
+
+  expect(decryptedMessage).toEqual(text);
+});
+
+test('Should encrypt and decrypt text by provided configs via keys', async () => {
+  const text = 'Hello world';
+  const res = await encrypt(text, {
+    type: 'gpgKeys',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+  });
+
+  expect(res.startsWith('-----BEGIN PGP MESSAGE-----')).toBeTruthy();
+
+  const decryptedMessage = await decrypt(res, {
+    type: 'gpgKeys',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+  });
+
+  expect(decryptedMessage).toEqual(text);
+});

package/encryption/encryption.ts

@@ -1,12 +1,14 @@
 import {
   createMessage,
-  decrypt,
+  decrypt as _decrypt,
   decryptKey,
-  encrypt,
+  encrypt as _encrypt,
   readKey,
   readMessage,
   readPrivateKey,
 } from 'openpgp';
+import { ModelsPublicNoteEncryptionTypeEnum } from 'src/remote-api';
+import { OrgNoteEncryption } from '..';
 
 export class IncorrectOrMissingPrivateKeyPasswordError extends Error {}
 export class ImpossibleToDecryptWithProvidedKeysError extends Error {}
@@ -41,6 +43,47 @@ export const encryptViaPassword = withCustomErrors(_encryptViaPassword);
 export const decryptViaPassword = withCustomErrors(_decryptViaPassword);
 export const decryptViaKeys = withCustomErrors(_decryptViaKeys);
 
+export const encrypt = async (
+  text: string,
+  encryptionParams: OrgNoteEncryption
+): Promise<string> => {
+  if (
+    !encryptionParams.type ||
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled
+  ) {
+    return text;
+  }
+  return encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+    ? await encryptViaKeys(
+        text,
+        encryptionParams.publicKey,
+        encryptionParams.privateKey,
+        encryptionParams.privateKeyPassphrase
+      )
+    : await encryptViaPassword(text, encryptionParams.password);
+};
+
+export const decrypt = async (
+  text: string,
+  encryptionParams: OrgNoteEncryption
+): Promise<string> => {
+  if (
+    !encryptionParams.type ||
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled
+  ) {
+    return text;
+  }
+  const decryptedNote =
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+      ? await decryptViaKeys(
+          text,
+          encryptionParams.privateKey,
+          encryptionParams.privateKeyPassphrase
+        )
+      : await decryptViaPassword(text, encryptionParams.password);
+  return decryptedNote;
+};
+
 async function _encryptViaPassword(
   text: string,
   password: string
@@ -49,7 +92,7 @@ async function _encryptViaPassword(
     text,
   });
 
-  const encryptedMessage = await encrypt({
+  const encryptedMessage = await _encrypt({
     message,
     format: 'armored',
     passwords: [password],
@@ -81,7 +124,7 @@ async function _encryptViaKeys(
       })
     : encryptedPrivateKey;
 
-  const encryptedMessage = await encrypt({
+  const encryptedMessage = await _encrypt({
     message,
     format: 'armored',
     encryptionKeys: publicKey,
@@ -97,7 +140,7 @@ async function _decryptViaPassword(
 ): Promise<string> {
   const message = await readMessage({ armoredMessage: data });
 
-  const { data: decryptedText } = await decrypt({
+  const { data: decryptedText } = await _decrypt({
     message,
     passwords: password,
   });
@@ -123,7 +166,7 @@ async function _decryptViaKeys(
 
   const message = await readMessage({ armoredMessage: data });
 
-  const { data: decryptedText } = await decrypt({
+  const { data: decryptedText } = await _decrypt({
     message,
     decryptionKeys: privateKey,
   });

package/encryption/note-encryption.ts

@@ -24,6 +24,7 @@ export interface AbstractEncryptedNote {
     published?: boolean;
   };
 }
+// TODO: master change signature for encrypt notes without content
 export async function encryptNote<T extends AbstractEncryptedNote>(
   note: T,
   encryptionParams: OrgNoteEncryption
@@ -88,13 +89,15 @@ 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
+    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
+    !isContentEncrypted
   ) {
-    note.encrypted = isGpgEncrypted(note.content);
+    note.encrypted = isContentEncrypted;
     return note;
   }
   note.encrypted = true;

package/models/note.ts

@@ -19,7 +19,7 @@ export interface NotePreview {
   encrypted?: boolean;
 }
 
-export interface Note extends ModelsPublicNote {
+export interface Note extends Omit<ModelsPublicNote, 'content'> {
   deleted?: Date;
   bookmarked?: boolean;
   encrypted?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orgnote-api",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Official API for creating extensions for OrgNote app",
   "type": "module",
   "main": "./index.ts",