orgnote-api 0.20.2 → 0.40.0

package/sync/types.d.ts

@@ -0,0 +1,74 @@
+import type { FileSystem } from '../models/file-system.js';
+import type { FileChange, SyncApiFactory } from '../remote-api/index.js';
+export type SyncApi = ReturnType<typeof SyncApiFactory>;
+export type SyncStatus = 'synced' | 'dirty' | 'uploading' | 'downloading' | 'error';
+export declare enum SyncOperationType {
+    Upload = "upload",
+    Download = "download",
+    DeleteLocal = "deleteLocal",
+    DeleteRemote = "deleteRemote"
+}
+export interface SyncedFile {
+    mtime: number;
+    size: number;
+    version?: number;
+    status: SyncStatus;
+    syncedAt?: string;
+    conflictPath?: string;
+    errorMessage?: string;
+}
+export interface SyncStateData {
+    files: Record<string, SyncedFile>;
+}
+export interface SyncState {
+    get(): Promise<SyncStateData>;
+    getFile(path: string): Promise<SyncedFile | null>;
+    setFile(path: string, file: SyncedFile): Promise<void>;
+    removeFile(path: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export interface LocalFile {
+    path: string;
+    mtime: number;
+    size: number;
+}
+export type RemoteFile = Pick<FileChange, 'path' | 'version' | 'deleted' | 'updatedAt'>;
+export type UploadResult = {
+    status: 'ok';
+    version: number;
+} | {
+    status: 'conflict';
+    serverVersion: number;
+};
+export interface SyncExecutor {
+    upload: (file: LocalFile, expectedVersion?: number) => Promise<UploadResult>;
+    download: (file: RemoteFile) => Promise<void>;
+    deleteLocal: (path: string) => Promise<void>;
+    deleteRemote: (path: string, expectedVersion: number) => Promise<void>;
+}
+export interface SyncPlan {
+    toUpload: LocalFile[];
+    toDownload: RemoteFile[];
+    toDeleteLocal: string[];
+    toDeleteRemote: string[];
+    serverTime: string;
+}
+export interface SyncTask {
+    path: string;
+    operation: SyncOperationType;
+    file?: LocalFile | RemoteFile;
+}
+export interface CreateSyncPlanParams {
+    fs: FileSystem;
+    api: SyncApi;
+    state: SyncState;
+    rootPath: string;
+    ignorePatterns?: string[];
+}
+export interface SyncContext {
+    executor: SyncExecutor;
+    state: SyncState;
+    fs: FileSystem;
+    serverTime: string;
+    deviceName?: string;
+}

package/sync/types.js

@@ -0,0 +1,7 @@
+export var SyncOperationType;
+(function (SyncOperationType) {
+    SyncOperationType["Upload"] = "upload";
+    SyncOperationType["Download"] = "download";
+    SyncOperationType["DeleteLocal"] = "deleteLocal";
+    SyncOperationType["DeleteRemote"] = "deleteRemote";
+})(SyncOperationType || (SyncOperationType = {}));

package/sync/utils/__tests__/oldest-synced-at.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/sync/utils/__tests__/oldest-synced-at.spec.js

@@ -0,0 +1,38 @@
+import { test, expect } from 'vitest';
+import { getOldestSyncedAt } from "../oldest-synced-at.js";
+const createFile = (syncedAt) => ({
+    mtime: 1000,
+    size: 100,
+    status: 'synced',
+    syncedAt,
+});
+test('returns undefined when no files', () => {
+    const state = { files: {} };
+    expect(getOldestSyncedAt(state)).toBeUndefined();
+});
+test('returns undefined when no files have syncedAt', () => {
+    const state = {
+        files: { '/a.org': createFile() },
+    };
+    expect(getOldestSyncedAt(state)).toBeUndefined();
+});
+test('returns oldest syncedAt from files', () => {
+    const state = {
+        files: {
+            '/a.org': createFile('2024-01-03T00:00:00Z'),
+            '/b.org': createFile('2024-01-01T00:00:00Z'),
+            '/c.org': createFile('2024-01-02T00:00:00Z'),
+        },
+    };
+    expect(getOldestSyncedAt(state)).toBe('2024-01-01T00:00:00Z');
+});
+test('ignores files without syncedAt', () => {
+    const state = {
+        files: {
+            '/a.org': createFile('2024-01-02T00:00:00Z'),
+            '/b.org': createFile(),
+            '/c.org': createFile('2024-01-03T00:00:00Z'),
+        },
+    };
+    expect(getOldestSyncedAt(state)).toBe('2024-01-02T00:00:00Z');
+});

package/sync/utils/oldest-synced-at.d.ts

@@ -0,0 +1,2 @@
+import type { SyncStateData } from '../types.js';
+export declare const getOldestSyncedAt: (stateData: SyncStateData) => string | undefined;

package/sync/utils/oldest-synced-at.js

@@ -0,0 +1,9 @@
+export const getOldestSyncedAt = (stateData) => {
+    const syncedTimes = Object.values(stateData.files)
+        .map((f) => f.syncedAt)
+        .filter((t) => Boolean(t));
+    if (syncedTimes.length === 0) {
+        return undefined;
+    }
+    return syncedTimes.reduce((oldest, current) => new Date(current) < new Date(oldest) ? current : oldest);
+};

package/utils/__tests__/find-files-diff.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/{tools → utils}/__tests__/find-files-diff.spec.js

@@ -2,7 +2,7 @@ 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.js";
-const testFilesFolder = 'src/tools/__tests__/miscellaneous2/';
+const testFilesFolder = 'src/utils/__tests__/miscellaneous2/';
 function initFiles() {
     mkdirSync(testFilesFolder);
     mkdirSync(testFilesFolder + '/nested-folder');
@@ -83,8 +83,8 @@ test('Should find files diff when folder was renamed', () => {
     {
       "created": [],
       "deleted": [
-        "src/tools/__tests__/miscellaneous2/nested-folder/org-file.org",
-        "src/tools/__tests__/miscellaneous2/nested-folder/org-file2.org",
+        "src/utils/__tests__/miscellaneous2/nested-folder/org-file.org",
+        "src/utils/__tests__/miscellaneous2/nested-folder/org-file2.org",
       ],
       "updated": [],
     }

package/utils/__tests__/find-note-files-diff.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/{tools → utils}/__tests__/find-note-files-diff.spec.js

@@ -5,7 +5,7 @@ import { statSync } from 'fs';
 import { rmSync } from 'fs';
 import { getFileName } from "../get-file-name.js";
 import { join } from "../join-path.js";
-const testFilesFolder = 'src/tools/__tests__/miscellaneous/';
+const testFilesFolder = 'src/utils/__tests__/miscellaneous/';
 const nestedFolder = 'nested-folder/';
 const fn = (fileName) => `${testFilesFolder}${fileName}`;
 const fns = (fileName) => `${testFilesFolder}${nestedFolder}${fileName}`;
@@ -95,21 +95,21 @@ test('Should sync notes files', async () => {
     {
       "created": [
         {
-          "filePath": "src/tools/__tests__/miscellaneous/file-2.org",
+          "filePath": "src/utils/__tests__/miscellaneous/file-2.org",
         },
         {
-          "filePath": "src/tools/__tests__/miscellaneous/nested-folder/file-4.org",
+          "filePath": "src/utils/__tests__/miscellaneous/nested-folder/file-4.org",
         },
       ],
       "deleted": [
         {
-          "filePath": "src/tools/__tests__/miscellaneous/nested-folder/file-10.org",
+          "filePath": "src/utils/__tests__/miscellaneous/nested-folder/file-10.org",
           "id": "10",
         },
       ],
       "updated": [
         {
-          "filePath": "src/tools/__tests__/miscellaneous/file-9.org",
+          "filePath": "src/utils/__tests__/miscellaneous/file-9.org",
         },
       ],
     }

package/utils/__tests__/get-file-name.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/get-string-path.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/is-gpg-encrypted.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/is-org-file.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/join.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/join.spec.js

@@ -0,0 +1,32 @@
+import { test, expect } from 'vitest';
+import { join } from "../join-path.js";
+test('joins relative paths', () => {
+    expect(join('dir1', 'subdir2', 'file')).toBe('dir1/subdir2/file');
+});
+test('joins paths with trailing slashes', () => {
+    expect(join('dir2/', '/file')).toBe('dir2/file');
+});
+test('joins absolute path with subdirs', () => {
+    expect(join('/dir3', 'subdir2/', 'file')).toBe('/dir3/subdir2/file');
+});
+test('returns single path as is', () => {
+    expect(join('file')).toBe('file');
+});
+test('preserves absolute path when first arg starts with /', () => {
+    expect(join('/', 'this', 'is-path')).toBe('/this/is-path');
+});
+test('filters standalone slashes in the middle', () => {
+    expect(join('path', '/', 'to', '/', 'file')).toBe('path/to/file');
+});
+test('handles empty string without adding slash', () => {
+    expect(join('', 'file')).toBe('file');
+});
+test('returns / for root only', () => {
+    expect(join('/')).toBe('/');
+});
+test('returns / for root with empty segments', () => {
+    expect(join('/', '')).toBe('/');
+});
+test('returns empty for empty input', () => {
+    expect(join('')).toBe('');
+});

package/utils/__tests__/nullable-guards.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/nullable-guards.spec.js

@@ -0,0 +1,44 @@
+import { test, expect } from 'vitest';
+import { isNullable, isPresent } from "../nullable-guards.js";
+test('isNullable returns true for null', () => {
+    expect(isNullable(null)).toBe(true);
+});
+test('isNullable returns true for undefined', () => {
+    expect(isNullable(undefined)).toBe(true);
+});
+test('isNullable returns false for valid values', () => {
+    expect(isNullable(0)).toBe(false);
+    expect(isNullable('')).toBe(false);
+    expect(isNullable(false)).toBe(false);
+    expect(isNullable([])).toBe(false);
+});
+test('isNullable returns true for NaN', () => {
+    expect(isNullable(NaN)).toBe(true);
+});
+test('isPresent returns false for null', () => {
+    expect(isPresent(null)).toBe(false);
+});
+test('isPresent returns false for undefined', () => {
+    expect(isPresent(undefined)).toBe(false);
+});
+test('isPresent returns true for valid values', () => {
+    expect(isPresent(0)).toBe(true);
+    expect(isPresent('')).toBe(true);
+    expect(isPresent(false)).toBe(true);
+    expect(isPresent([])).toBe(true);
+});
+test('isPresent returns false for NaN', () => {
+    expect(isPresent(NaN)).toBe(false);
+});
+test('type guards work with TypeScript narrowing', () => {
+    const value = 'test';
+    if (isPresent(value)) {
+        const upper = value.toUpperCase();
+        expect(upper).toBe('TEST');
+    }
+});
+test('isPresent filters array correctly', () => {
+    const arr = [1, null, 2, undefined, 3];
+    const filtered = arr.filter(isPresent);
+    expect(filtered).toEqual([1, 2, 3]);
+});

package/utils/__tests__/parent-folder.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/read-org-files-recursively.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/split-path.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/to-absolute-path.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/to-absolute-path.spec.js

@@ -0,0 +1,26 @@
+import { test, expect } from 'vitest';
+import { toAbsolutePath, toRelativePath } from "../to-absolute-path.js";
+test('toAbsolutePath adds leading slash to relative path', () => {
+    expect(toAbsolutePath('folder/file.org')).toBe('/folder/file.org');
+});
+test('toAbsolutePath keeps absolute path unchanged', () => {
+    expect(toAbsolutePath('/folder/file.org')).toBe('/folder/file.org');
+});
+test('toAbsolutePath handles empty string', () => {
+    expect(toAbsolutePath('')).toBe('/');
+});
+test('toAbsolutePath handles root path', () => {
+    expect(toAbsolutePath('/')).toBe('/');
+});
+test('toRelativePath removes leading slash from absolute path', () => {
+    expect(toRelativePath('/folder/file.org')).toBe('folder/file.org');
+});
+test('toRelativePath keeps relative path unchanged', () => {
+    expect(toRelativePath('folder/file.org')).toBe('folder/file.org');
+});
+test('toRelativePath handles root path', () => {
+    expect(toRelativePath('/')).toBe('');
+});
+test('toRelativePath handles empty string', () => {
+    expect(toRelativePath('')).toBe('');
+});

package/utils/__tests__/to-error.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/to-error.spec.js

@@ -0,0 +1,112 @@
+import { describe, it, expect } from 'vitest';
+import { to } from "../to-error.js";
+import { ok } from 'neverthrow';
+describe('to-error utility', () => {
+    describe('synchronous functions', () => {
+        it('should return Ok(result) when function succeeds', () => {
+            const fn = () => 42;
+            const wrapped = to(fn);
+            const result = wrapped();
+            expect(result).toEqual(ok(42));
+        });
+        it('should return Err(Error) when function throws', () => {
+            const fn = () => {
+                throw new Error('boom');
+            };
+            const wrapped = to(fn);
+            const result = wrapped();
+            expect(result.isErr()).toBe(true);
+            if (result.isErr()) {
+                expect(result.error).toBeInstanceOf(Error);
+                expect(result.error.message).toBe('boom');
+            }
+        });
+        it('should use custom error mapper function', () => {
+            const fn = () => {
+                throw new Error('boom');
+            };
+            const mapper = (e) => new Error(`Custom: ${e instanceof Error ? e.message : e}`);
+            const wrapped = to(fn, mapper);
+            const result = wrapped();
+            expect(result.isErr()).toBe(true);
+            if (result.isErr()) {
+                expect(result.error.message).toBe('Custom: boom');
+            }
+        });
+        it('should wrap error with message when string is provided', () => {
+            const fn = () => {
+                throw new Error('original error');
+            };
+            const wrapped = to(fn, 'Context message');
+            const result = wrapped();
+            expect(result.isErr()).toBe(true);
+            if (result.isErr()) {
+                expect(result.error.message).toBe('Context message');
+                expect(result.error.cause).toBeInstanceOf(Error);
+                expect(result.error.cause.message).toBe('original error');
+            }
+        });
+    });
+    describe('asynchronous functions', () => {
+        it('should return Ok(result) when promise resolves', async () => {
+            const fn = async () => 42;
+            const wrapped = to(fn);
+            const result = await wrapped();
+            expect(result).toEqual(ok(42));
+        });
+        it('should return Err(Error) when promise rejects', async () => {
+            const fn = async () => {
+                throw new Error('async boom');
+            };
+            const wrapped = to(fn);
+            const result = await wrapped();
+            expect(result.isErr()).toBe(true);
+            if (result.isErr()) {
+                expect(result.error).toBeInstanceOf(Error);
+                expect(result.error.message).toBe('async boom');
+            }
+        });
+        it('should map async errors', async () => {
+            const fn = async () => {
+                throw new Error('async boom');
+            };
+            const mapper = () => new Error('mapped async error');
+            const wrapped = to(fn, mapper);
+            const result = await wrapped();
+            expect(result.isErr()).toBe(true);
+            if (result.isErr()) {
+                expect(result.error.message).toBe('mapped async error');
+            }
+        });
+    });
+    describe('argument passing', () => {
+        it('should pass arguments to the original function', () => {
+            const fn = (a, b) => a + b;
+            const wrapped = to(fn);
+            const result = wrapped(2, 3);
+            expect(result).toEqual(ok(5));
+        });
+        it('should pass arguments to async function', async () => {
+            const fn = async (a) => `Hello ${a}`;
+            const wrapped = to(fn);
+            const result = await wrapped('World');
+            expect(result).toEqual(ok('Hello World'));
+        });
+    });
+    describe('context binding', () => {
+        it('should preserve this context', () => {
+            class Calculator {
+                multiplier;
+                constructor(multiplier) {
+                    this.multiplier = multiplier;
+                }
+                multiply(value) {
+                    return value * this.multiplier;
+                }
+            }
+            const calc = new Calculator(2);
+            const wrapped = to(calc.multiply.bind(calc));
+            expect(wrapped(3)).toEqual(ok(6));
+        });
+    });
+});

package/utils/__tests__/with-root.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/with-root.spec.js

@@ -0,0 +1,20 @@
+import { expect, test } from 'vitest';
+import { withRoot } from "../with-root.js";
+test('adds root to path without leading slash', () => {
+    expect(withRoot('test')).toBe('/test');
+});
+test('leaves path unchanged if starts with slash', () => {
+    expect(withRoot('/test')).toBe('/test');
+});
+test('handles empty string', () => {
+    expect(withRoot('')).toBe('/');
+});
+test('handles multiple leading slashes', () => {
+    expect(withRoot('//test')).toBe('//test');
+});
+test('handles path with trailing slash', () => {
+    expect(withRoot('test/')).toBe('/test/');
+});
+test('handles root path', () => {
+    expect(withRoot('/')).toBe('/');
+});

package/{tools → utils}/find-notes-files-diff.js

@@ -20,10 +20,12 @@ export async function getOrgFilesFromLastSync(filePaths, fileInfo, lastSync) {
     if (!lastSync) {
         return filePaths;
     }
-    return Promise.all(filePaths.filter(async (filePath) => {
+    const results = await Promise.all(filePaths.map(async (filePath) => {
         const stats = await fileInfo(filePath);
-        return (new Date(stats.mtime) > lastSync || new Date(stats.ctime) > lastSync);
+        const isModified = new Date(stats.mtime) > lastSync || new Date(stats.ctime) > lastSync;
+        return isModified ? filePath : null;
     }));
+    return results.filter((p) => p !== null);
 }
 function findDeletedNotes(filePaths, storedNotesInfo) {
     const uniqueFilePaths = new Set(filePaths);
@@ -50,7 +52,8 @@ async function findUpdatedCreatedNotes(fileInfo, orgFilePaths, storedNotesInfo)
             continue;
         }
         const fileUpdatedTime = new Date((await fileInfo(f))?.mtime);
-        if (found.updatedAt < fileUpdatedTime) {
+        const storedUpdatedTime = new Date(found.updatedAt);
+        if (storedUpdatedTime < fileUpdatedTime) {
             updated.push({ filePath: f });
         }
     }

package/{tools → utils}/index.d.ts

@@ -1,4 +1,3 @@
-export * from './mock-server.js';
 export * from './is-gpg-encrypted.js';
 export * from './is-org-file.js';
 export * from './get-string-path.js';
@@ -7,3 +6,7 @@ export * from './find-notes-files-diff.js';
 export * from './join-path.js';
 export * from './split-path.js';
 export * from './get-parent-dir.js';
+export * from './toml.js';
+export * from './to-absolute-path.js';
+export * from './to-error.js';
+export * from './nullable-guards.js';

package/{tools → utils}/index.js

@@ -1,4 +1,3 @@
-export * from "./mock-server.js";
 export * from "./is-gpg-encrypted.js";
 export * from "./is-org-file.js";
 export * from "./get-string-path.js";
@@ -7,3 +6,7 @@ export * from "./find-notes-files-diff.js";
 export * from "./join-path.js";
 export * from "./split-path.js";
 export * from "./get-parent-dir.js";
+export * from "./toml.js";
+export * from "./to-absolute-path.js";
+export * from "./to-error.js";
+export * from "./nullable-guards.js";

package/utils/join-path.d.ts

@@ -0,0 +1 @@
+export declare function join(...paths: string[]): string;

package/utils/join-path.js

@@ -0,0 +1,13 @@
+export function join(...paths) {
+    const isAbsolute = paths[0]?.startsWith('/');
+    const result = paths
+        .filter((p) => p !== '/' && p)
+        .join('/')
+        .replace(/\/+/g, '/')
+        .replace(/\/+$/, '');
+    if (!result)
+        return isAbsolute ? '/' : '';
+    if (isAbsolute && !result.startsWith('/'))
+        return `/${result}`;
+    return result;
+}

package/utils/nullable-guards.d.ts

@@ -0,0 +1,2 @@
+export declare function isNullable<T>(value: T | null | undefined): value is null | undefined;
+export declare function isPresent<T>(value: T | null | undefined): value is T;

package/utils/nullable-guards.js

@@ -0,0 +1,6 @@
+export function isNullable(value) {
+    return (value === null || value === undefined || (typeof value === 'number' && Number.isNaN(value)));
+}
+export function isPresent(value) {
+    return (value !== null && value !== undefined && !(typeof value === 'number' && Number.isNaN(value)));
+}

package/utils/to-absolute-path.d.ts

@@ -0,0 +1,2 @@
+export declare const toAbsolutePath: (path: string) => string;
+export declare const toRelativePath: (path: string) => string;

package/utils/to-absolute-path.js

@@ -0,0 +1,2 @@
+export const toAbsolutePath = (path) => path.startsWith('/') ? path : `/${path}`;
+export const toRelativePath = (path) => path.startsWith('/') ? path.slice(1) : path;

package/utils/to-error.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from 'neverthrow';
+import { ResultAsync } from 'neverthrow';
+type MapperOrMsg<E> = ((e: unknown) => E) | string;
+export declare function to<R, TThis = unknown, A extends any[] = any[], E = Error>(fn: (this: TThis, ...args: A) => Promise<R>, mapErrorOrMsg?: MapperOrMsg<E>): (this: TThis, ...args: A) => ResultAsync<R, E>;
+export declare function to<R, TThis = unknown, A extends any[] = any[], E = Error>(fn: (this: TThis, ...args: A) => R, mapErrorOrMsg?: MapperOrMsg<E>): (this: TThis, ...args: A) => Result<R, E>;
+export {};

package/utils/to-error.js

@@ -0,0 +1,33 @@
+import { ResultAsync, ok, err } from 'neverthrow';
+import { isPresent } from "./nullable-guards.js";
+const defaultToError = (e) => (e instanceof Error ? e : new Error(String(e)));
+function isPromiseLike(x) {
+    return (typeof x === 'object' &&
+        isPresent(x) &&
+        'then' in x &&
+        typeof x.then === 'function');
+}
+function resolveMapper(map) {
+    if (typeof map === 'function')
+        return map;
+    if (typeof map === 'string') {
+        const msg = map;
+        return (e) => new Error(msg, { cause: e instanceof Error ? e : new Error(String(e)) });
+    }
+    return defaultToError;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function to(fn, mapErrorOrMsg) {
+    const mapError = resolveMapper(mapErrorOrMsg);
+    return function (...args) {
+        try {
+            const out = fn.apply(this, args);
+            if (isPromiseLike(out))
+                return ResultAsync.fromPromise(out, mapError);
+            return ok(out);
+        }
+        catch (e) {
+            return err(mapError(e));
+        }
+    };
+}

package/utils/toml.d.ts

@@ -0,0 +1,3 @@
+import { BaseSchema, InferOutput } from 'valibot';
+export declare function parseToml<T = unknown, S extends BaseSchema<unknown, unknown, any> | undefined = undefined>(content: string, schema?: S): S extends BaseSchema<unknown, unknown, any> ? InferOutput<S> : T;
+export declare function stringifyToml(data: unknown): string;