trilium-api 1.0.0 → 1.0.2

package/src/client.test.ts

@@ -1,477 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { createTriliumClient } from './client.js';
-
-// Mock fetch globally - openapi-fetch uses Request objects
-const mockFetch = vi.fn();
-globalThis.fetch = mockFetch;
-
-// Helper to create a proper Response mock
-function createMockResponse(body: any, status = 200, contentType = 'application/json') {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    headers: new Headers({ 'content-type': contentType }),
-    json: async () => body,
-    text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
-    blob: async () => new Blob([JSON.stringify(body)]),
-    clone: function() { return this; },
-  };
-}
-
-describe('createTriliumClient', () => {
-  const config = {
-    baseUrl: 'http://localhost:37840',
-    apiKey: 'test-api-key',
-  };
-
-  beforeEach(() => {
-    mockFetch.mockReset();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('client creation', () => {
-    it('should create a client with correct baseUrl', () => {
-      const client = createTriliumClient(config);
-      expect(client).toBeDefined();
-      expect(typeof client.GET).toBe('function');
-      expect(typeof client.POST).toBe('function');
-      expect(typeof client.PATCH).toBe('function');
-      expect(typeof client.DELETE).toBe('function');
-    });
-
-    it('should handle trailing slash in baseUrl', () => {
-      const clientWithSlash = createTriliumClient({
-        baseUrl: 'http://localhost:37840/',
-        apiKey: 'test-api-key',
-      });
-      expect(clientWithSlash).toBeDefined();
-    });
-  });
-
-  describe('GET /app-info', () => {
-    it('should fetch app info', async () => {
-      const mockAppInfo = {
-        appVersion: '0.60.0',
-        dbVersion: 220,
-        syncVersion: 30,
-        buildDate: '2024-01-01T00:00:00Z',
-        buildRevision: 'abc123',
-        dataDirectory: '/home/user/data',
-        clipperProtocolVersion: 1,
-        utcDateTime: '2024-01-01T12:00:00Z',
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockAppInfo));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/app-info');
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockAppInfo);
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      
-      // Check the Request object
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toBe('http://localhost:37840/etapi/app-info');
-      expect(request.method).toBe('GET');
-    });
-  });
-
-  describe('GET /notes/{noteId}', () => {
-    it('should fetch a note by ID', async () => {
-      const mockNote = {
-        noteId: 'test123',
-        title: 'Test Note',
-        type: 'text',
-        mime: 'text/html',
-        isProtected: false,
-        blobId: 'blob123',
-        attributes: [],
-        parentNoteIds: ['root'],
-        childNoteIds: [],
-        parentBranchIds: ['branch123'],
-        childBranchIds: [],
-        dateCreated: '2024-01-01 12:00:00.000+0000',
-        dateModified: '2024-01-01 12:00:00.000+0000',
-        utcDateCreated: '2024-01-01 12:00:00.000Z',
-        utcDateModified: '2024-01-01 12:00:00.000Z',
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockNote));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/notes/{noteId}', {
-        params: { path: { noteId: 'test123' } },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockNote);
-      
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toBe('http://localhost:37840/etapi/notes/test123');
-      expect(request.method).toBe('GET');
-    });
-
-    it('should handle 404 error when note not found', async () => {
-      const errorResponse = { status: 404, code: 'NOTE_NOT_FOUND', message: 'Note not found' };
-      mockFetch.mockResolvedValueOnce(createMockResponse(errorResponse, 404));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/notes/{noteId}', {
-        params: { path: { noteId: 'nonexistent' } },
-      });
-
-      expect(data).toBeUndefined();
-      expect(error).toBeDefined();
-    });
-  });
-
-  describe('GET /notes (search)', () => {
-    it('should search notes with query', async () => {
-      const mockResults = {
-        results: [
-          { noteId: 'note1', title: 'Blog Post 1' },
-          { noteId: 'note2', title: 'Blog Post 2' },
-        ],
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockResults));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/notes', {
-        params: { query: { search: '#blog' } },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockResults);
-      
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toContain('search=%23blog');
-    });
-
-    it('should search with limit parameter', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse({ results: [] }));
-
-      const client = createTriliumClient(config);
-      await client.GET('/notes', {
-        params: { query: { search: 'test', limit: 10 } },
-      });
-
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toContain('limit=10');
-    });
-  });
-
-  describe('POST /create-note', () => {
-    it('should create a new note', async () => {
-      const mockCreatedNote = {
-        note: {
-          noteId: 'newNote123',
-          title: 'New Note',
-          type: 'text',
-          mime: 'text/html',
-          isProtected: false,
-        },
-        branch: {
-          branchId: 'branch456',
-          noteId: 'newNote123',
-          parentNoteId: 'root',
-          notePosition: 10,
-          isExpanded: false,
-        },
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockCreatedNote, 201));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.POST('/create-note', {
-        body: {
-          parentNoteId: 'root',
-          title: 'New Note',
-          type: 'text',
-          content: '<p>Hello World</p>',
-        },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockCreatedNote);
-      
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toBe('http://localhost:37840/etapi/create-note');
-      expect(request.method).toBe('POST');
-    });
-  });
-
-  describe('PATCH /notes/{noteId}', () => {
-    it('should patch a note', async () => {
-      const mockUpdatedNote = {
-        noteId: 'test123',
-        title: 'Updated Title',
-        type: 'text',
-        mime: 'text/html',
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockUpdatedNote));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.PATCH('/notes/{noteId}', {
-        params: { path: { noteId: 'test123' } },
-        body: { title: 'Updated Title' },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data?.title).toBe('Updated Title');
-      
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toBe('http://localhost:37840/etapi/notes/test123');
-      expect(request.method).toBe('PATCH');
-    });
-  });
-
-  describe('DELETE /notes/{noteId}', () => {
-    it('should delete a note', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse('', 204, 'text/plain'));
-
-      const client = createTriliumClient(config);
-      const { error } = await client.DELETE('/notes/{noteId}', {
-        params: { path: { noteId: 'test123' } },
-      });
-
-      expect(error).toBeUndefined();
-      
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toBe('http://localhost:37840/etapi/notes/test123');
-      expect(request.method).toBe('DELETE');
-    });
-  });
-
-  describe('GET /notes/{noteId}/content', () => {
-    it('should fetch note content', async () => {
-      const mockContent = '<p>This is the note content</p>';
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockContent, 200, 'text/html'));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/notes/{noteId}/content', {
-        params: { path: { noteId: 'test123' } },
-      });
-
-      expect(error).toBeUndefined();
-      // Content comes back as parsed
-      expect(data).toBeDefined();
-    });
-  });
-
-  describe('PUT /notes/{noteId}/content', () => {
-    it('should update note content', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse('', 204, 'text/plain'));
-
-      const client = createTriliumClient(config);
-      const { error } = await client.PUT('/notes/{noteId}/content', {
-        params: { path: { noteId: 'test123' } },
-        body: '<p>Updated content</p>' as any,
-      });
-
-      expect(error).toBeUndefined();
-      
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.url).toBe('http://localhost:37840/etapi/notes/test123/content');
-      expect(request.method).toBe('PUT');
-    });
-  });
-
-  describe('Branches API', () => {
-    it('should create a branch', async () => {
-      const mockBranch = {
-        branchId: 'branch123',
-        noteId: 'note123',
-        parentNoteId: 'parent123',
-        notePosition: 10,
-        prefix: '',
-        isExpanded: false,
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockBranch, 201));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.POST('/branches', {
-        body: {
-          noteId: 'note123',
-          parentNoteId: 'parent123',
-        },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockBranch);
-    });
-
-    it('should get a branch by ID', async () => {
-      const mockBranch = {
-        branchId: 'branch123',
-        noteId: 'note123',
-        parentNoteId: 'root',
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockBranch));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/branches/{branchId}', {
-        params: { path: { branchId: 'branch123' } },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockBranch);
-    });
-
-    it('should delete a branch', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse('', 204, 'text/plain'));
-
-      const client = createTriliumClient(config);
-      const { error } = await client.DELETE('/branches/{branchId}', {
-        params: { path: { branchId: 'branch123' } },
-      });
-
-      expect(error).toBeUndefined();
-    });
-  });
-
-  describe('Attributes API', () => {
-    it('should create an attribute', async () => {
-      const mockAttribute = {
-        attributeId: 'attr123',
-        noteId: 'note123',
-        type: 'label',
-        name: 'testLabel',
-        value: 'testValue',
-        position: 10,
-        isInheritable: false,
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockAttribute, 201));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.POST('/attributes', {
-        body: {
-          noteId: 'note123',
-          type: 'label',
-          name: 'testLabel',
-          value: 'testValue',
-        },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockAttribute);
-    });
-
-    it('should get an attribute by ID', async () => {
-      const mockAttribute = {
-        attributeId: 'attr123',
-        noteId: 'note123',
-        type: 'label',
-        name: 'testLabel',
-        value: 'testValue',
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockAttribute));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/attributes/{attributeId}', {
-        params: { path: { attributeId: 'attr123' } },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockAttribute);
-    });
-
-    it('should delete an attribute', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse('', 204, 'text/plain'));
-
-      const client = createTriliumClient(config);
-      const { error } = await client.DELETE('/attributes/{attributeId}', {
-        params: { path: { attributeId: 'attr123' } },
-      });
-
-      expect(error).toBeUndefined();
-    });
-  });
-
-  describe('Attachments API', () => {
-    it('should get an attachment by ID', async () => {
-      const mockAttachment = {
-        attachmentId: 'attach123',
-        ownerId: 'note123',
-        role: 'file',
-        mime: 'image/png',
-        title: 'test.png',
-        position: 10,
-        blobId: 'blob123',
-      };
-
-      mockFetch.mockResolvedValueOnce(createMockResponse(mockAttachment));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/attachments/{attachmentId}', {
-        params: { path: { attachmentId: 'attach123' } },
-      });
-
-      expect(error).toBeUndefined();
-      expect(data).toEqual(mockAttachment);
-    });
-
-    it('should delete an attachment', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse('', 204, 'text/plain'));
-
-      const client = createTriliumClient(config);
-      const { error } = await client.DELETE('/attachments/{attachmentId}', {
-        params: { path: { attachmentId: 'attach123' } },
-      });
-
-      expect(error).toBeUndefined();
-    });
-  });
-
-  describe('Authorization header', () => {
-    it('should include Authorization header in requests', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse({}));
-
-      const client = createTriliumClient(config);
-      await client.GET('/app-info');
-
-      const request = mockFetch.mock.calls[0]![0] as Request;
-      expect(request.headers.get('Authorization')).toBe('test-api-key');
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should handle network errors', async () => {
-      mockFetch.mockRejectedValueOnce(new Error('Network error'));
-
-      const client = createTriliumClient(config);
-      
-      await expect(client.GET('/app-info')).rejects.toThrow('Network error');
-    });
-
-    it('should handle 500 server errors', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse({ status: 500, message: 'Internal Server Error' }, 500));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/app-info');
-
-      expect(data).toBeUndefined();
-      expect(error).toBeDefined();
-    });
-
-    it('should handle 401 unauthorized errors', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse({ status: 401, message: 'Unauthorized' }, 401));
-
-      const client = createTriliumClient(config);
-      const { data, error } = await client.GET('/app-info');
-
-      expect(data).toBeUndefined();
-      expect(error).toBeDefined();
-    });
-  });
-});

package/src/client.ts

@@ -1,91 +0,0 @@
-/**
- * Trilium API Client using openapi-fetch
- * 
- * This provides a type-safe client for the Trilium ETAPI.
- * Types are auto-generated from the OpenAPI specification.
- */
-
-import createClient from 'openapi-fetch';
-import type { paths, components } from './generated/trilium.js';
-
-// Re-export common types for convenience
-export type TriliumNote = components['schemas']['Note'];
-export type TriliumBranch = components['schemas']['Branch'];
-export type TriliumAttribute = components['schemas']['Attribute'];
-export type TriliumAttachment = components['schemas']['Attachment'];
-export type TriliumAppInfo = components['schemas']['AppInfo'];
-
-// Export the paths type for advanced usage
-export type { paths, components };
-
-// Re-export mapper utilities
-export {
-  TriliumMapper,
-  buildSearchQuery,
-  transforms,
-  type MappingConfig,
-  type FieldMapping,
-  type TransformFunction,
-  type ComputedFunction,
-  type TriliumSearchHelpers,
-  type TriliumSearchConditions,
-  type TriliumSearchLogical,
-  type ComparisonOperator,
-  type ConditionValue,
-  type SearchValue,
-} from './mapper.js';
-
-export interface TriliumClientConfig {
-  baseUrl: string;
-  apiKey: string;
-}
-
-/**
- * Create a type-safe Trilium API client
- * 
- * @example
- * ```ts
- * const client = createTriliumClient({
- *   baseUrl: 'http://localhost:37840',
- *   apiKey: 'your-etapi-token'
- * });
- * 
- * // Get app info
- * const { data, error } = await client.GET('/app-info');
- * 
- * // Get a note by ID
- * const { data: note } = await client.GET('/notes/{noteId}', {
- *   params: { path: { noteId: 'root' } }
- * });
- * 
- * // Create a note
- * const { data: newNote } = await client.POST('/notes', {
- *   body: {
- *     parentNoteId: 'root',
- *     title: 'My Note',
- *     type: 'text',
- *     content: '<p>Hello World</p>'
- *   }
- * });
- * 
- * // Search notes
- * const { data: searchResults } = await client.GET('/notes', {
- *   params: { query: { search: '#blog' } }
- * });
- * ```
- */
-export function createTriliumClient(config: TriliumClientConfig) {
-  const baseUrl = config.baseUrl.endsWith('/') 
-    ? config.baseUrl.slice(0, -1) 
-    : config.baseUrl;
-
-  return createClient<paths>({
-    baseUrl: `${baseUrl}/etapi`,
-    headers: {
-      Authorization: config.apiKey,
-    },
-  });
-}
-
-// Default export for convenience
-export default createTriliumClient;