orgnote-api 0.15.3 → 0.17.0

package/encryption/__tests__/encryption.spec.ts

@@ -329,3 +329,24 @@ test('Should armor and unarmor encrypted file', async () => {
 
   expect(data).toEqual(content);
 });
+
+test('Should decrypt value from provided real world data and passwords', async () => {
+  const text = `Hello world!`;
+  const password = 'qweqwebebe1';
+
+  const encryptedContent = await encrypt({
+    content: text,
+    type: 'gpgPassword',
+    password,
+  });
+
+  const armoredContent = armor(encryptedContent as unknown as Uint8Array);
+
+  const decryptedMessage = await decrypt({
+    content: armoredContent,
+    type: 'gpgPassword',
+    password,
+  });
+
+  expect(decryptedMessage).toEqual('Hello world!');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orgnote-api",
-  "version": "0.15.3",
+  "version": "0.17.0",
   "description": "Official API for creating extensions for OrgNote app",
   "type": "module",
   "main": "./index.ts",
@@ -45,6 +45,7 @@
     "axios": "1.7.3",
     "openpgp": "5.11.1",
     "org-mode-ast": "0.11.7",
+    "orgnote-api": "0.16.0",
     "vue": "3.4.15",
     "vue-router": "4.2.5"
   },

package/tools/__tests__/find-notes-files-diff.spec.ts

@@ -0,0 +1,176 @@
+import { afterEach, beforeEach, expect, test } from 'vitest';
+import { mkdirSync, rmdirSync, statSync, utimesSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { findNotesFilesDiff, StoredNoteInfo } from '../find-notes-files-diff';
+
+const testFilesFolder = 'src/tools/__tests__/miscellaneous/';
+
+function initFiles(): void {
+  mkdirSync(testFilesFolder);
+  mkdirSync(testFilesFolder + '/nested-folder');
+}
+
+function cleanFiles(): void {
+  try {
+    rmdirSync(testFilesFolder, { recursive: true });
+  } catch (e) {}
+}
+
+function createTestFile(
+  content: string,
+  fileName: string,
+  updated: Date
+): void {
+  const filePath = join(testFilesFolder, fileName);
+
+  writeFileSync(filePath, content);
+
+  const time = updated.getTime() / 1000; // Convert to seconds
+  utimesSync(filePath, time, time);
+}
+
+beforeEach(() => initFiles());
+afterEach(() => cleanFiles());
+
+test('Should find files diff', () => {
+  createTestFile(`unchanged file!`, 'org-file.org', new Date('2021-01-01'));
+  createTestFile(
+    `changed org file 2!`,
+    'org-file2.org',
+    new Date('2022-01-01')
+  );
+  createTestFile(
+    `deleted org in the nested folder file!`,
+    'nested-folder/org-file3.org',
+    new Date('2021-01-01')
+  );
+  createTestFile(
+    `created file in the nested folder!`,
+    'nested-folder/org-file4.org',
+    new Date('2021-02-01')
+  );
+
+  const storedNoteInfos: StoredNoteInfo[] = [
+    {
+      filePath: [testFilesFolder + 'deleted-org-file.org'],
+      id: 'deleted-org-file.org',
+      updatedAt: new Date('2021-01-01'),
+    },
+    {
+      filePath: [testFilesFolder + 'org-file.org'],
+      id: 'org-file.org',
+      updatedAt: new Date('2021-01-01'),
+    },
+    {
+      filePath: [testFilesFolder + 'org-file2.org'],
+      id: 'org-file2.org',
+      updatedAt: new Date('2021-01-01'),
+    },
+    {
+      filePath: [testFilesFolder + 'nested-folder/org-file3.org'],
+      id: 'nested-folder/org-file3.org',
+      updatedAt: new Date('2021-01-01'),
+    },
+  ];
+
+  const changedFiles = findNotesFilesDiff(
+    [
+      testFilesFolder + 'org-file.org',
+      testFilesFolder + 'org-file2.org',
+      testFilesFolder + 'nested-folder/org-file3.org',
+      testFilesFolder + 'nested-folder/org-file4.org',
+    ],
+    storedNoteInfos,
+    (filePath: string) => new Date(statSync(filePath).mtime)
+  );
+
+  expect(changedFiles).toEqual({
+    created: [testFilesFolder + 'nested-folder/org-file4.org'],
+    updated: [testFilesFolder + 'org-file2.org'],
+    deleted: [testFilesFolder + 'deleted-org-file.org'],
+  });
+});
+
+test('Should find files diff when folder was renamed', () => {
+  createTestFile(
+    `nested file!`,
+    'nested-folder/org-file.org',
+    new Date('2021-01-01')
+  );
+  createTestFile(
+    `nested file2!`,
+    'nested-folder/org-file-2.org',
+    new Date('2021-01-01')
+  );
+
+  const storedNoteInfos: StoredNoteInfo[] = [
+    {
+      filePath: [testFilesFolder + 'nested-folder/org-file.org'],
+      id: 'nested-folder/org-file.org',
+      updatedAt: new Date('2021-01-01'),
+    },
+    {
+      filePath: [testFilesFolder + 'nested-folder/org-file2.org'],
+      id: 'nested-folder/org-file2.org',
+      updatedAt: new Date('2021-01-01'),
+    },
+  ];
+
+  rmdirSync(testFilesFolder + 'nested-folder', { recursive: true });
+
+  const changedFiles = findNotesFilesDiff(
+    [],
+    storedNoteInfos,
+    (filePath: string) => new Date(statSync(filePath).mtime)
+  );
+
+  expect(changedFiles).toMatchInlineSnapshot(`
+    {
+      "created": [],
+      "deleted": [
+        "src/tools/__tests__/miscellaneous/nested-folder/org-file.org",
+        "src/tools/__tests__/miscellaneous/nested-folder/org-file2.org",
+      ],
+      "updated": [],
+    }
+  `);
+});
+
+test('Should find created note when nested folder created', () => {
+  mkdirSync(testFilesFolder + 'new-nested-folder');
+  createTestFile(
+    `new nested file!`,
+    'new-nested-folder/org-file.org',
+    new Date('2023-01-01')
+  );
+
+  const storedNoteInfos: StoredNoteInfo[] = [];
+
+  const changedFiles = findNotesFilesDiff(
+    [testFilesFolder + 'new-nested-folder/org-file.org'],
+    storedNoteInfos,
+    (filePath: string) => new Date(statSync(filePath).mtime)
+  );
+
+  expect(changedFiles).toEqual({
+    created: [testFilesFolder + 'new-nested-folder/org-file.org'],
+    updated: [],
+    deleted: [],
+  });
+});
+
+test('Should find nothing when no files provided', () => {
+  const storedNoteInfos: StoredNoteInfo[] = [];
+
+  const changedFiles = findNotesFilesDiff(
+    [],
+    storedNoteInfos,
+    (filePath: string) => new Date(statSync(filePath).mtime)
+  );
+
+  expect(changedFiles).toEqual({
+    created: [],
+    updated: [],
+    deleted: [],
+  });
+});

package/tools/__tests__/get-string-path.spec.ts

@@ -0,0 +1,32 @@
+import { getStringPath } from '../get-string-path';
+import { test, expect } from 'vitest';
+
+test('should return the same string if path is a string', () => {
+  const path = 'some/path';
+  const result = getStringPath(path);
+  expect(result).toBe('some/path');
+});
+
+test('should join array elements with "/" if path is an array', () => {
+  const path = ['some', 'path'];
+  const result = getStringPath(path);
+  expect(result).toBe('some/path');
+});
+
+test('should return an empty string if path is an empty array', () => {
+  const path: string[] = [];
+  const result = getStringPath(path);
+  expect(result).toBe('');
+});
+
+test('should handle array with one element correctly', () => {
+  const path = ['single'];
+  const result = getStringPath(path);
+  expect(result).toBe('single');
+});
+
+test('should handle array with multiple elements correctly', () => {
+  const path = ['this', 'is', 'a', 'test'];
+  const result = getStringPath(path);
+  expect(result).toBe('this/is/a/test');
+});

package/tools/__tests__/is-org-file.spec.ts

@@ -0,0 +1,62 @@
+import { test, expect } from 'vitest';
+import { isOrgFile, isOrgGpgFile } from '../is-org-file';
+
+test('Should return true for org files', () => {
+  const files = [
+    'myNote.org',
+    'my_note.org',
+    '123.org',
+    'some_long_note#4123$123eqasdasd.org.gpg',
+    'some_long_note#4123$123eqasdasd.org',
+    'note with space.org',
+    'note with space.org.gpg',
+  ];
+
+  files.forEach((file) => {
+    expect(isOrgFile(file), file).toBe(true);
+  });
+});
+
+test('Should not return true for non-org files', () => {
+  const files = [
+    'myNote.md',
+    'my_note.md',
+    '123.md',
+    'some_long_note#4123$123eqasdas',
+    'note.org.file',
+    'org',
+    'org.',
+    'text.gpg',
+  ];
+
+  files.forEach((file) => {
+    expect(isOrgFile(file), file).toBe(false);
+  });
+});
+
+test('Should return true for org.gpg files', () => {
+  const gpgFiles = [
+    'myNote.org.gpg',
+    'my_note.org.gpg',
+    '123.org.gpg',
+    'org.org.gpg',
+    'gp_org.org.gpg',
+  ];
+
+  gpgFiles.forEach((file) => {
+    expect(isOrgGpgFile(file), file).toBe(true);
+  });
+});
+
+test('Should not return true for not .org.gpg files', () => {
+  const notGpgFiles = [
+    'myNote.org',
+    'my_note.org',
+    '123.org',
+    'some_gpg_file.txt',
+  ];
+
+  notGpgFiles.forEach((file) => {
+    expect(isOrgGpgFile(file), file).toBe(false);
+  });
+});

package/tools/find-notes-files-diff.ts

@@ -0,0 +1,48 @@
+import { getStringPath } from './get-string-path';
+
+export interface ChangedFiles {
+  deleted: string[];
+  created: string[];
+  updated: string[];
+}
+
+export interface StoredNoteInfo {
+  filePath: string[];
+  id: string;
+  updatedAt: string | Date;
+}
+
+export function findNotesFilesDiff(
+  filePaths: string[],
+  storedNotesInfo: StoredNoteInfo[],
+  updatedTimeGetter: (filePath: string) => Date
+): ChangedFiles {
+  const existingFilePaths = new Set<string>(filePaths);
+
+  const storedNotesPathSet = new Set<string>(
+    storedNotesInfo.map((n) => getStringPath(n.filePath))
+  );
+  const changedFiles: ChangedFiles = { deleted: [], created: [], updated: [] };
+
+  storedNotesInfo.forEach((storedNote) => {
+    const fullPath = getStringPath(storedNote.filePath);
+    if (!existingFilePaths.has(fullPath)) {
+      changedFiles.deleted.push(fullPath);
+      return;
+    }
+
+    const updatedTime = updatedTimeGetter(fullPath);
+    if (updatedTime > new Date(storedNote.updatedAt)) {
+      changedFiles.updated.push(fullPath);
+    }
+  });
+
+  filePaths.forEach((filePath) => {
+    if (!storedNotesPathSet.has(filePath)) {
+      changedFiles.created.push(filePath);
+      return;
+    }
+  });
+
+  return changedFiles;
+}

package/tools/get-string-path.ts

@@ -0,0 +1,6 @@
+export function getStringPath(path: string | string[]): string {
+  if (Array.isArray(path)) {
+    return `${path.join('/')}`;
+  }
+  return path;
+}

package/tools/index.ts

@@ -1,2 +1,3 @@
 export * from './mock-server';
 export * from './is-gpg-encrypted';
+export * from './is-org-file';

package/tools/is-org-file.ts

@@ -0,0 +1,7 @@
+const orgFileExtenstionRegex = /\.org(\.gpg)?$/;
+export const isOrgFile = (fileName: string): boolean =>
+  orgFileExtenstionRegex.test(fileName);
+
+const orgGpgFileExtenstionRegex = /\.org\.gpg$/;
+export const isOrgGpgFile = (fileName: string): boolean =>
+  orgGpgFileExtenstionRegex.test(fileName);