orgnote-api 0.16.0 → 0.17.1

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

@@ -46,22 +46,6 @@ exports[`Should decrypt note via provided keys 1`] = `
 ]
 `;
 
-exports[`Should encrypt note and decrypt it into binary format 1`] = `
-{
-  "author": {
-    "email": "test@mail.com",
-    "id": "1",
-    "name": "John Doe",
-  },
-  "encrypted": true,
-  "id": "id",
-  "meta": {
-    "id": undefined,
-    "published": false,
-  },
-}
-`;
-
 exports[`Should encrypt note content via password 1`] = `
 {
   "author": {

package/encryption/__tests__/encryption.spec.ts

@@ -19,10 +19,11 @@ import {
   armoredPrivateKey,
   privateKeyPassphrase,
 } from './encryption-keys';
-// import { armor } from 'openpgp';
+import { ModelsPublicNoteEncryptionTypeEnum } from 'src/remote-api';
 
 test('Should encrypt text as armored message via keys', async () => {
   const res = await encryptViaKeys({
+    type: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
     content: 'Hello world',
     publicKey: armoredPublicKey,
     privateKey: armoredPrivateKey,
@@ -35,6 +36,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,
     content: 'Hello world',
     publicKey: armoredPublicKey,
     privateKey: armoredPrivateKey,
@@ -88,6 +90,7 @@ YQ==
 test('Should encrypt via password', async () => {
   const password = 'test';
   const res = await encryptViaPassword({
+    type: ModelsPublicNoteEncryptionTypeEnum.GpgPassword,
     content: 'Hello world',
     password,
     format: 'armored',
@@ -325,7 +328,28 @@ test('Should armor and unarmor encrypted file', async () => {
     "
   `);
 
-  const { text, data } = await unarmor(armored);
+  const { data } = await unarmor(armored);
 
   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/encryption/__tests__/note-encryption.spec.ts

@@ -289,7 +289,6 @@ test('Should not decrypt note without provided encrypted type', async () => {
     content: noteText,
     type: 'gpgPassword',
     password: '123',
-    format: 'armored',
   });
 
   expect(decryptedInfo).toMatchSnapshot();

package/encryption/encryption.ts

@@ -177,6 +177,7 @@ async function _decryptViaPassword<
   >;
 }
 
+// TODO: master OrgNoteGpgDecryption type
 async function _decryptViaKeys<
   T extends Omit<WithDecryptionContent<OrgNoteGpgEncryption>, 'type'>,
 >({

package/encryption/note-encryption.ts

@@ -19,6 +19,7 @@ export interface AbstractEncryptedNote {
 }
 
 export type EncryptionResult<T> = Promise<[T, string]>;
+export type DecryptionResult<T> = Promise<[T, string | Uint8Array]>;
 
 // TODO: master change signature for encrypt notes without content
 export async function encryptNote<T extends AbstractEncryptedNote>(
@@ -46,7 +47,7 @@ export async function encryptNote<T extends AbstractEncryptedNote>(
 export async function decryptNote<T extends AbstractEncryptedNote>(
   note: T,
   encryptionParams: WithNoteDecryptionContent<OrgNoteEncryption>
-): EncryptionResult<T> {
+): DecryptionResult<T> {
   const isContentEncrypted = isGpgEncrypted(encryptionParams.content);
   if (
     note.meta.published ||

package/models/encryption.ts

@@ -15,7 +15,7 @@ export interface OrgNoteGpgEncryption {
   /* Armored private key */
   privateKey: string;
   /* Armored public key */
-  publicKey: string;
+  publicKey?: string;
   privateKeyPassphrase?: string;
 }
 
@@ -41,10 +41,14 @@ export type WithEncryptionContent<
   T extends OrgNoteEncryption = OrgNoteEncryption,
 > = T & EncryptionData & BaseOrgNoteEncryption;
 
+export type DecriptionData = {
+  content: string | Uint8Array;
+};
+
 export type WithDecryptionContent<
   T extends OrgNoteEncryption = OrgNoteEncryption,
-> = T & EncryptionData & BaseOrgNoteDecryption;
+> = T & DecriptionData & BaseOrgNoteDecryption;
 
 export type WithNoteDecryptionContent<
   T extends OrgNoteEncryption = OrgNoteEncryption,
-> = T & EncryptionData;
+> = T & DecriptionData;

package/models/file-system.ts

@@ -0,0 +1,30 @@
+export interface FileInfo {
+  name: string;
+  path: string;
+  type: 'directory' | 'file';
+  size: number;
+  atime?: number;
+  ctime?: number;
+  mtime: number;
+  uri?: string;
+}
+
+export interface FileSystem {
+  readFile: <T extends 'utf8'>(
+    path: string,
+    encoding?: T
+  ) => Promise<T extends 'utf8' ? string : Uint8Array>;
+  writeFile: (
+    path: string,
+    content: string | Uint8Array,
+    encoding?: BufferEncoding
+  ) => Promise<void>;
+  readDir: (path: string) => Promise<FileInfo[]>;
+  fileInfo: (path: string) => Promise<FileInfo>;
+  rename: (path: string, newPath: string) => Promise<void>;
+  deleteFile: (path: string) => Promise<void>;
+  rmdir: (path: string) => Promise<void>;
+  mkdir: (path: string) => Promise<void>;
+  isDirExist: (path: string) => Promise<boolean>;
+  isFileExist: (path: string) => Promise<boolean>;
+}

package/models/index.ts

@@ -9,3 +9,5 @@ export * from './widget-type';
 export * from './editor';
 export * from './default-commands';
 export * from './encryption';
+export * from './file-system';
+export * from './sync';

package/models/sync.ts

@@ -0,0 +1,43 @@
+import { HandlersCreatingNote } from 'src/remote-api';
+import { FileSystem } from './file-system';
+
+export interface Changes {
+  deleted: string[];
+  created: string[];
+  updated: string[];
+}
+
+export interface NoteChange {
+  filePath: string;
+  id?: string;
+}
+
+export interface NoteChanges {
+  deleted: NoteChange[];
+  created: NoteChange[];
+  updated: NoteChange[];
+}
+
+export interface FullContextNoteChanges
+  extends Omit<NoteChanges, 'created' | 'updated'> {
+  created: HandlersCreatingNote[];
+  updated: HandlersCreatingNote[];
+}
+
+export interface StoredNoteInfo {
+  filePath: string[];
+  id: string;
+  updatedAt: string | Date;
+}
+
+export interface FileScanParams {
+  readDir: FileSystem['readDir'];
+  fileInfo: FileSystem['fileInfo'];
+  dirPath: string;
+}
+
+export interface SyncParams extends FileScanParams {
+  storedNotesInfo: StoredNoteInfo[];
+  /* Will be used instead of updated time from the storedNoteInfo property */
+  lastSync?: Date;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orgnote-api",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "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__/__snapshots__/join.spec.ts.snap

@@ -0,0 +1,9 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Should join file paths 1`] = `"dir1/subdir2/file"`;
+
+exports[`Should join file paths 2`] = `"dir2/file"`;
+
+exports[`Should join file paths 3`] = `"/dri3/subdir2/file"`;
+
+exports[`Should join file paths 4`] = `"file"`;

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

@@ -0,0 +1,177 @@
+import { afterEach, beforeEach, expect, test } from 'vitest';
+import { mkdirSync, rmdirSync, statSync, utimesSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { findFilesDiff } from '../find-notes-files-diff';
+import { StoredNoteInfo } from '../../models';
+
+const testFilesFolder = 'src/tools/__tests__/miscellaneous2/';
+
+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 = findFilesDiff(
+    [
+      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 = findFilesDiff(
+    [],
+    storedNoteInfos,
+    (filePath: string) => new Date(statSync(filePath).mtime)
+  );
+
+  expect(changedFiles).toMatchInlineSnapshot(`
+    {
+      "created": [],
+      "deleted": [
+        "src/tools/__tests__/miscellaneous2/nested-folder/org-file.org",
+        "src/tools/__tests__/miscellaneous2/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 = findFilesDiff(
+    [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 = findFilesDiff(
+    [],
+    storedNoteInfos,
+    (filePath: string) => new Date(statSync(filePath).mtime)
+  );
+
+  expect(changedFiles).toEqual({
+    created: [],
+    updated: [],
+    deleted: [],
+  });
+});

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

@@ -0,0 +1,207 @@
+import { mkdirSync, writeFileSync, utimesSync, readdirSync } from 'fs';
+import { afterEach, beforeEach, test, expect } from 'vitest';
+import { FileInfo, StoredNoteInfo } from '../../models';
+import { findNoteFilesDiff } from '../find-notes-files-diff';
+import { statSync } from 'fs';
+import { Stats } from 'fs';
+import { rmSync } from 'fs';
+import { getFileName } from '../get-file-name';
+import { join } from '../join';
+
+const testFilesFolder = 'src/tools/__tests__/miscellaneous/';
+const nestedFolder = 'nested-folder/';
+const fn = (fileName: string) => `${testFilesFolder}${fileName}`;
+const fns = (fileName: string) =>
+  `${testFilesFolder}${nestedFolder}${fileName}`;
+
+function initFiles(): void {
+  mkdirSync(testFilesFolder.slice(0, -1));
+  mkdirSync(fn(nestedFolder));
+}
+
+function cleanFiles(): void {
+  try {
+    rmSync(testFilesFolder, { recursive: true });
+  } catch (e) {}
+}
+
+function createTestFile(
+  filePath: string,
+  updated: Date,
+  content: string
+): void {
+  writeFileSync(filePath, content);
+
+  const time = updated.getTime() / 1000; // Convert to seconds
+  utimesSync(filePath, time, time);
+}
+
+beforeEach(() => initFiles());
+afterEach(() => cleanFiles());
+
+const fileStatToFileInfo = (path: string, stat: Stats): FileInfo => ({
+  path,
+  name: getFileName(path),
+  type: stat.isFile() ? 'file' : 'directory',
+  size: stat.size,
+  atime: stat.atime.getTime(),
+  mtime: stat.mtime.getTime(),
+  ctime: stat.ctime.getTime(),
+});
+
+test('Should sync notes files', async () => {
+  const files = [
+    [fn('file-1.org')],
+    [fn('file-2.org')],
+    [fn('file-9.org'), new Date('2024-10-10')],
+    [fns('file-3.org')],
+    [fns('file-4.org'), new Date('2024-08-09')],
+  ] as const;
+
+  files.forEach(([f, d], i) =>
+    createTestFile(
+      f,
+      d ?? new Date('2024-01-01'),
+      `:PROPERTIES:
+:ID: ${i + 1}
+:PROPERTIES:
+
+* Hello world from note:
+- ${f}`
+    )
+  );
+
+  const storedNotesInfo: StoredNoteInfo[] = [
+    {
+      id: '2',
+      filePath: fn('file-1.org').split('/'),
+      updatedAt: new Date('2024-01-01'),
+    },
+    {
+      id: '3',
+      filePath: fns('file-3.org').split('/'),
+      updatedAt: new Date('2024-01-01'),
+    },
+    {
+      id: '9',
+      filePath: fn('file-9.org').split('/'),
+      updatedAt: new Date('2020-01-01'),
+    },
+    {
+      id: '10',
+      filePath: fns('file-10.org').split('/'),
+      updatedAt: new Date('2020-01-01'),
+    },
+  ];
+
+  const notesFilesDiff = await findNoteFilesDiff({
+    fileInfo: async (path: string) => {
+      const stats = statSync(path);
+
+      const fileInfo: FileInfo = fileStatToFileInfo(path, stats);
+
+      return Promise.resolve(fileInfo);
+    },
+    readDir: async (path: string) => {
+      const dirents = readdirSync(path, { withFileTypes: true });
+
+      const fileInfos: FileInfo[] = dirents.map((dirent) => {
+        const stats = statSync(join(path, dirent.name));
+        const fileInfo = fileStatToFileInfo(join(path, dirent.name), stats);
+        return fileInfo;
+      });
+
+      return Promise.resolve(fileInfos);
+    },
+    storedNotesInfo,
+    dirPath: testFilesFolder,
+  });
+
+  expect(notesFilesDiff).toMatchInlineSnapshot(`
+    {
+      "created": [
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/file-2.org",
+        },
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/nested-folder/file-4.org",
+        },
+      ],
+      "deleted": [
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/nested-folder/file-10.org",
+          "id": "10",
+        },
+      ],
+      "updated": [
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/file-9.org",
+        },
+      ],
+    }
+  `);
+});
+
+test('Should detect no changes when all files match stored info', async () => {
+  const files = [
+    [fn('file-1.org'), new Date('2024-01-01')],
+    [fn('file-2.org'), new Date('2024-01-01')],
+    [fns('file-3.org'), new Date('2024-01-01')],
+  ] as const;
+
+  files.forEach(([f, d], i) =>
+    createTestFile(
+      f,
+      d ?? new Date('2024-01-01'),
+      `:PROPERTIES:
+:ID: ${i + 1}
+:PROPERTIES:
+
+* Note:
+- ${f}`
+    )
+  );
+
+  const storedNotesInfo: StoredNoteInfo[] = [
+    {
+      id: '1',
+      filePath: fn('file-1.org').split('/'),
+      updatedAt: new Date('2024-01-01'),
+    },
+    {
+      id: '2',
+      filePath: fn('file-2.org').split('/'),
+      updatedAt: new Date('2024-01-01'),
+    },
+    {
+      id: '3',
+      filePath: fns('file-3.org').split('/'),
+      updatedAt: new Date('2024-01-01'),
+    },
+  ];
+
+  const notesFilesDiff = await findNoteFilesDiff({
+    fileInfo: async (path: string) => {
+      const stats = statSync(path);
+      const fileInfo: FileInfo = fileStatToFileInfo(path, stats);
+      return Promise.resolve(fileInfo);
+    },
+    readDir: async (path: string) => {
+      const dirents = readdirSync(path, { withFileTypes: true });
+      const fileInfos: FileInfo[] = dirents.map((dirent) => {
+        const stats = statSync(join(path, dirent.name));
+        const fileInfo = fileStatToFileInfo(join(path, dirent.name), stats);
+        return fileInfo;
+      });
+      return Promise.resolve(fileInfos);
+    },
+    storedNotesInfo,
+    dirPath: testFilesFolder,
+  });
+
+  expect(notesFilesDiff).toEqual({
+    created: [],
+    updated: [],
+    deleted: [],
+  });
+});

package/tools/__tests__/get-file-name.spec.ts

@@ -0,0 +1,18 @@
+import { getFileName, getFileNameWithoutExtension } from '../get-file-name';
+import { test, expect } from 'vitest';
+
+test('Should return file name from path', () => {
+  expect(getFileName('/some/path/foo.org')).toBe('foo.org');
+});
+
+test('Should return file name from file name', () => {
+  expect(getFileName('foo.org')).toBe('foo.org');
+});
+
+test('Should return file name without extension', () => {
+  expect(getFileNameWithoutExtension('foo.org')).toBe('foo');
+});
+
+test('Should return file name without extension from path', () => {
+  expect(getFileNameWithoutExtension('/some/path/foo.org')).toBe('foo');
+});

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__/join.spec.ts

@@ -0,0 +1,16 @@
+import { test, expect } from 'vitest';
+import { join } from '../join';
+
+test('Should join file paths', () => {
+  const samples = [
+    ['dir1', 'subdir2', 'file'],
+    ['dir2/', '/file'],
+    ['/dri3', 'subdir2/', 'file'],
+    ['file'],
+  ];
+
+  samples.forEach((sample) => {
+    const result = join(...sample);
+    expect(result).toMatchSnapshot();
+  });
+});

package/tools/__tests__/read-org-files-recursively.spec.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi } from 'vitest';
+import { readOrgFilesRecursively } from '../find-notes-files-diff';
+import { FileScanParams } from '../../models';
+
+// NOTE: AI generated
+const mockReadDir = vi.fn();
+const mockFileInfo = vi.fn();
+
+describe('readOrgFilesRecursively', () => {
+  it('should read .org files recursively from a directory', async () => {
+    const mockFileSystem: FileScanParams = {
+      fileInfo: mockFileInfo,
+      readDir: mockReadDir,
+      dirPath: '/root',
+    };
+
+    // Set up fake file system structure
+    mockReadDir.mockImplementation(async (path) => {
+      switch (path) {
+        case '/root':
+          return [
+            { name: 'file1.org', type: 'file', size: 100, mtime: Date.now() },
+            { name: 'subdir', type: 'directory', size: 0, mtime: Date.now() },
+            { name: 'file2.txt', type: 'file', size: 200, mtime: Date.now() },
+          ];
+        case '/root/subdir':
+          return [
+            { name: 'file3.org', type: 'file', size: 100, mtime: Date.now() },
+            { name: 'file4.md', type: 'file', size: 150, mtime: Date.now() },
+          ];
+        default:
+          return [];
+      }
+    });
+
+    // Execute the function
+    const orgFiles = await readOrgFilesRecursively(mockFileSystem);
+
+    // Check results
+    expect(orgFiles).toEqual(['/root/file1.org', '/root/subdir/file3.org']);
+    expect(mockReadDir).toHaveBeenCalledTimes(2);
+  });
+
+  it('should return an empty array if no .org files are found', async () => {
+    const mockFileSystem: FileScanParams = {
+      fileInfo: mockFileInfo,
+      readDir: mockReadDir,
+      dirPath: '/emptyDir',
+    };
+
+    // Set up fake file system structure with no .org files
+    mockReadDir.mockResolvedValue([]);
+
+    // Execute the function
+    const orgFiles = await readOrgFilesRecursively(mockFileSystem);
+
+    // Check results
+    expect(orgFiles).toEqual([]);
+    expect(mockReadDir).toHaveBeenCalledWith('/emptyDir');
+  });
+});

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

@@ -0,0 +1,35 @@
+import { HandlersCreatingNote, HandlersSyncNotesRequest } from 'src/remote-api';
+import { NoteChange, NoteChanges, FileSystem } from '../models';
+import { isOrgGpgFile } from './is-org-file';
+
+export async function extendNotesFilesDiff(
+  changes: NoteChanges,
+  readFile: FileSystem['readFile']
+): Promise<HandlersSyncNotesRequest> {
+  const upsertedNotesFromLastSync: NoteChange[] = [
+    ...changes.updated,
+    ...changes.created,
+  ];
+
+  const notesFromLastSync: HandlersCreatingNote[] = [];
+
+  for (const nc of upsertedNotesFromLastSync) {
+    const encrypted = isOrgGpgFile(nc.filePath);
+  }
+
+  const noteIdsFromLastSync = new Set(notesFromLastSync.map((n) => n.id));
+
+  const deletedNotesIdsWithoutRename = changes.deleted.reduce<string[]>(
+    (acc, nc) => {
+      if (!noteIdsFromLastSync.has(nc.id)) {
+        acc.push(nc.id);
+      }
+      return acc;
+    },
+    []
+  );
+
+  return {
+    deletedNotesIds: deletedNotesIdsWithoutRename,
+  };
+}

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

@@ -0,0 +1,185 @@
+import {
+  SyncParams,
+  Changes,
+  StoredNoteInfo,
+  NoteChanges,
+  FileScanParams,
+  FileSystem,
+  NoteChange,
+} from 'src/models';
+import { getStringPath } from './get-string-path';
+import { isOrgFile } from './is-org-file';
+import { join } from './join';
+
+export async function findNoteFilesDiff({
+  fileInfo,
+  readDir,
+  lastSync,
+  storedNotesInfo,
+  dirPath,
+}: SyncParams): Promise<NoteChanges> {
+  const orgFilePaths = await readOrgFilesRecursively({
+    fileInfo,
+    readDir,
+    dirPath,
+  });
+
+  const filesFromLastSync = await getOrgFilesFromLastSync(
+    orgFilePaths,
+    fileInfo,
+    lastSync
+  );
+
+  const deleted = findDeletedNotes(orgFilePaths, storedNotesInfo);
+
+  const [created, updated] = await findUpdatedCreatedNotes(
+    fileInfo,
+    filesFromLastSync,
+    storedNotesInfo
+  );
+
+  return {
+    deleted,
+    created,
+    updated,
+  };
+}
+
+export async function getOrgFilesFromLastSync(
+  filePaths: string[],
+  fileInfo: FileSystem['fileInfo'],
+  lastSync?: Date
+): Promise<string[]> {
+  if (!lastSync) {
+    return filePaths;
+  }
+
+  return Promise.all(
+    filePaths.filter(async (filePath) => {
+      const stats = await fileInfo(filePath);
+      return (
+        new Date(stats.mtime) > lastSync || new Date(stats.ctime) > lastSync
+      );
+    })
+  );
+}
+
+function findDeletedNotes(
+  filePaths: string[],
+  storedNotesInfo: StoredNoteInfo[]
+): NoteChange[] {
+  const uniqueFilePaths = new Set(filePaths);
+
+  return storedNotesInfo.reduce((acc, storedNote) => {
+    const storedNotePath = getStringPath(storedNote.filePath);
+    if (uniqueFilePaths.has(storedNotePath)) {
+      return acc;
+    }
+    acc.push({
+      filePath: storedNotePath,
+      id: storedNote.id,
+    });
+    return acc;
+  }, []);
+}
+
+async function findUpdatedCreatedNotes(
+  fileInfo: FileSystem['fileInfo'],
+  orgFilePaths: string[],
+  storedNotesInfo: StoredNoteInfo[]
+): Promise<[NoteChange[], NoteChange[]]> {
+  const created: NoteChange[] = [];
+  const updated: NoteChange[] = [];
+
+  const storedNotesInfoMap = getStoredNotesInfoMap(storedNotesInfo);
+
+  for (const f of orgFilePaths) {
+    const found = storedNotesInfoMap[f];
+    if (!found) {
+      created.push({ filePath: f });
+      continue;
+    }
+    const fileUpdatedTime = new Date((await fileInfo(f))?.mtime);
+    if (found.updatedAt < fileUpdatedTime) {
+      updated.push({ filePath: f });
+    }
+  }
+
+  return [created, updated];
+}
+
+function getStoredNotesInfoMap(storedNotesInfo: StoredNoteInfo[]): {
+  [key: string]: StoredNoteInfo;
+} {
+  return storedNotesInfo.reduce((acc, n) => {
+    acc[getStringPath(n.filePath)] = n;
+    return acc;
+  }, {});
+}
+
+export async function readOrgFilesRecursively({
+  fileInfo,
+  readDir,
+  dirPath,
+}: FileScanParams): Promise<string[]> {
+  const files = await readDir(dirPath);
+
+  const collectedPaths: string[] = [];
+  const getFullPath = (p: string) => join(dirPath, p);
+
+  for (const f of files) {
+    if (f.type === 'directory') {
+      const subDirFiles = await readOrgFilesRecursively({
+        fileInfo,
+        readDir,
+        dirPath: getFullPath(f.name),
+      });
+
+      collectedPaths.push(...subDirFiles);
+      continue;
+    }
+
+    if (!isOrgFile(f.name)) {
+      continue;
+    }
+
+    collectedPaths.push(getFullPath(f.name));
+  }
+
+  return collectedPaths;
+}
+
+export function findFilesDiff(
+  filePaths: string[],
+  storedNotesInfo: StoredNoteInfo[],
+  updatedTimeGetter: (filePath: string) => Date
+): Changes {
+  const existingFilePaths = new Set<string>(filePaths);
+
+  const storedNotesPathSet = new Set<string>(
+    storedNotesInfo.map((n) => getStringPath(n.filePath))
+  );
+  const changedFiles: Changes = { 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-file-name.ts

@@ -0,0 +1,7 @@
+export const getFileName = (path: string): string => {
+  return path.split('/').pop();
+};
+
+export const getFileNameWithoutExtension = (path: string): string => {
+  return getFileName(path).split('.').shift();
+};

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,3 +1,6 @@
 export * from './mock-server';
 export * from './is-gpg-encrypted';
 export * from './is-org-file';
+export * from './get-string-path';
+export * from './find-notes-files-diff';
+export * from './join';

package/tools/join.ts

@@ -0,0 +1,3 @@
+export function join(...path: string[]): string {
+  return path.join('/').replace(/\/+/g, '/').replace(/\/+$/, '');
+}