@markwharton/liquidplanner 1.12.0 → 2.0.0

package/dist/client.d.ts

@@ -6,7 +6,8 @@
  *
  * @see https://api-docs.liquidplanner.com/
  */
-import type { LPConfig, LPWorkspace, LPMember, LPItem, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPUpsertOptions, LPAssignmentWithContext, LPAncestor, LPErrorInfo, LPFindItemsOptions, LPWorkspaceTree } from './types.js';
+import type { Result } from '@markwharton/api-core';
+import type { LPConfig, LPWorkspace, LPMember, LPItem, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPUpsertOptions, LPAssignmentWithContext, LPAncestor, LPFindItemsOptions, LPWorkspaceTree } from './types.js';
 /**
  * LiquidPlanner API Client
  *
@@ -80,34 +81,26 @@ export declare class LPClient {
      * Fetch a URL and parse the response, with standardized error handling.
      */
     private fetchAndParse;
+    /**
+     * Fetch and parse with isDuplicate support for mutation methods.
+     */
+    private fetchAndParseMutation;
     /**
      * Validate the API token by listing workspaces
      */
-    validateToken(): Promise<{
-        valid: boolean;
-        error?: string;
-    }>;
+    validateToken(): Promise<Result<void>>;
     /**
      * Get all workspaces accessible to the API token
      */
-    getWorkspaces(): Promise<{
-        workspaces?: LPWorkspace[];
-        error?: LPErrorInfo;
-    }>;
+    getWorkspaces(): Promise<Result<LPWorkspace[]>>;
     /**
      * Get all members in the workspace (with pagination)
      */
-    getWorkspaceMembers(): Promise<{
-        members?: LPMember[];
-        error?: LPErrorInfo;
-    }>;
+    getWorkspaceMembers(): Promise<Result<LPMember[]>>;
     /**
      * Get a single item by ID
      */
-    getItem(itemId: number): Promise<{
-        item?: LPItem;
-        error?: LPErrorInfo;
-    }>;
+    getItem(itemId: number): Promise<Result<LPItem>>;
     /**
      * Get multiple items by ID in a single request (batch fetch)
      *
@@ -116,10 +109,7 @@ export declare class LPClient {
      *
      * @param itemIds - Array of item IDs to fetch
      */
-    getItems(itemIds: number[]): Promise<{
-        items?: LPItem[];
-        error?: LPErrorInfo;
-    }>;
+    getItems(itemIds: number[]): Promise<Result<LPItem[]>>;
     /**
      * Get the ancestry chain for an item
      *
@@ -128,27 +118,18 @@ export declare class LPClient {
      *
      * @param itemId - The item ID to get ancestors for
      */
-    getItemAncestors(itemId: number): Promise<{
-        ancestors?: LPAncestor[];
-        error?: LPErrorInfo;
-    }>;
+    getItemAncestors(itemId: number): Promise<Result<LPAncestor[]>>;
     /**
      * Find all assignments under a task (with pagination)
      */
-    findAssignments(taskId: number): Promise<{
-        assignments?: LPItem[];
-        error?: LPErrorInfo;
-    }>;
+    findAssignments(taskId: number): Promise<Result<LPItem[]>>;
     /**
      * Get all assignments for a specific member
      *
      * This enables PWA apps to show a task picker populated from LP directly.
      * Note: userId is not a supported filter field in the LP API, so we filter client-side.
      */
-    getMyAssignments(memberId: number): Promise<{
-        assignments?: LPItem[];
-        error?: LPErrorInfo;
-    }>;
+    getMyAssignments(memberId: number): Promise<Result<LPItem[]>>;
     /**
      * Get assignments for a member with parent task names resolved
      *
@@ -168,10 +149,7 @@ export declare class LPClient {
     getMyAssignmentsWithContext(memberId: number, options?: {
         includeProject?: boolean;
         includeHierarchy?: boolean;
-    }): Promise<{
-        assignments?: LPAssignmentWithContext[];
-        error?: LPErrorInfo;
-    }>;
+    }): Promise<Result<LPAssignmentWithContext[]>>;
     /**
      * Query items with LP API filters
      *
@@ -183,10 +161,7 @@ export declare class LPClient {
      *
      * @param options - Filter options (all optional, combined with AND)
      */
-    findItems(options: LPFindItemsOptions): Promise<{
-        items?: LPItem[];
-        error?: LPErrorInfo;
-    }>;
+    findItems(options: LPFindItemsOptions): Promise<Result<LPItem[]>>;
     /**
      * Get direct children of an item
      *
@@ -198,10 +173,7 @@ export declare class LPClient {
      */
     getChildren(parentId: number, options?: {
         itemType?: string;
-    }): Promise<{
-        items?: LPItem[];
-        error?: LPErrorInfo;
-    }>;
+    }): Promise<Result<LPItem[]>>;
     /**
      * Fetch a snapshot of the active workspace tree
      *
@@ -214,10 +186,7 @@ export declare class LPClient {
      * After the initial fetch, all hierarchy queries (ancestors, paths, assignments
      * with context) can be answered from the cached tree with zero API calls.
      */
-    getWorkspaceTree(): Promise<{
-        tree?: LPWorkspaceTree;
-        error?: LPErrorInfo;
-    }>;
+    getWorkspaceTree(): Promise<Result<LPWorkspaceTree>>;
     /**
      * Get a member's active work with full context from the workspace tree
      *
@@ -229,18 +198,14 @@ export declare class LPClient {
      *
      * @param memberId - The member ID to get work for
      */
-    getMyWork(memberId: number): Promise<{
-        assignments?: LPAssignmentWithContext[];
-        treeItemCount?: number;
-        error?: LPErrorInfo;
-    }>;
+    getMyWork(memberId: number): Promise<Result<{
+        assignments: LPAssignmentWithContext[];
+        treeItemCount: number;
+    }>>;
     /**
      * Get all cost codes in the workspace (with pagination)
      */
-    getCostCodes(): Promise<{
-        costCodes?: LPCostCode[];
-        error?: LPErrorInfo;
-    }>;
+    getCostCodes(): Promise<Result<LPCostCode[]>>;
     /**
      * Create a timesheet entry (log time)
      *
@@ -262,10 +227,7 @@ export declare class LPClient {
      * @param date - Date(s) in YYYY-MM-DD format (string or array)
      * @param itemId - Optional item ID to filter by
      */
-    getTimesheetEntries(date: string | string[], itemId?: number): Promise<{
-        entries?: LPTimesheetEntryWithId[];
-        error?: LPErrorInfo;
-    }>;
+    getTimesheetEntries(date: string | string[], itemId?: number): Promise<Result<LPTimesheetEntryWithId[]>>;
     /**
      * Update an existing timesheet entry
      *

package/dist/client.js

@@ -10,7 +10,7 @@ import { buildAuthHeader, hoursToMinutes, normalizeItemType, filterIs, filterIsN
 import { buildTree, getTreeAncestors } from './tree.js';
 import { parseLPErrorResponse } from './errors.js';
 import { LP_API_BASE } from './constants.js';
-import { TTLCache, batchMap, getErrorMessage, fetchWithRetry } from '@markwharton/api-core';
+import { TTLCache, batchMap, getErrorMessage, fetchWithRetry, ok, err } from '@markwharton/api-core';
 /** Transform raw API item to LPItem, preserving scheduling and effort fields */
 function transformItem(raw) {
     const item = {
@@ -217,12 +217,30 @@ export class LPClient {
             if (!response.ok) {
                 const errorText = await response.text();
                 const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
-                return { error: { message, statusCode: response.status, isDuplicate } };
+                return { ok: false, error: message, status: response.status, ...(isDuplicate ? { isDuplicate } : {}) };
             }
-            return { data: await parse(response) };
+            return ok(await parse(response));
         }
         catch (error) {
-            return { error: { message: getErrorMessage(error), statusCode: 0 } };
+            return err(getErrorMessage(error), 0);
+        }
+    }
+    /**
+     * Fetch and parse with isDuplicate support for mutation methods.
+     */
+    async fetchAndParseMutation(url, parse, fetchOptions) {
+        try {
+            const response = await this.fetch(url, fetchOptions);
+            if (!response.ok) {
+                const errorText = await response.text();
+                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
+                return { ok: false, error: message, status: response.status, isDuplicate };
+            }
+            const data = await parse(response);
+            return { ok: true, data };
+        }
+        catch (error) {
+            return { ok: false, error: getErrorMessage(error), status: 0 };
         }
     }
     // ============================================================================
@@ -236,15 +254,15 @@ export class LPClient {
         try {
             const response = await this.fetch(url);
             if (response.ok) {
-                return { valid: true };
+                return { ok: true };
             }
             if (response.status === 401 || response.status === 403) {
-                return { valid: false, error: 'Invalid or expired API token' };
+                return err('Invalid or expired API token', response.status);
             }
-            return { valid: false, error: `Unexpected response: HTTP ${response.status}` };
+            return err(`Unexpected response: HTTP ${response.status}`, response.status);
         }
         catch (error) {
-            return { valid: false, error: getErrorMessage(error) || 'Connection failed' };
+            return err(getErrorMessage(error) || 'Connection failed');
         }
     }
     /**
@@ -252,11 +270,10 @@ export class LPClient {
      */
     async getWorkspaces() {
         const url = `${this.baseUrl}/workspaces/v1`;
-        const { data, error } = await this.fetchAndParse(url, async (r) => {
+        return this.fetchAndParse(url, async (r) => {
             const result = await r.json();
             return (result.data || []).map(ws => ({ id: ws.id, name: ws.name }));
         });
-        return error ? { error } : { workspaces: data };
     }
     // ============================================================================
     // Members
@@ -267,7 +284,7 @@ export class LPClient {
     async getWorkspaceMembers() {
         return this.cached('members', this.cacheTtl.membersTtl, async () => {
             const baseUrl = this.workspaceUrl('users/v1');
-            const { results, error } = await paginatedFetch({
+            return paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
                 transform: (data) => data.map(m => ({
@@ -279,7 +296,6 @@ export class LPClient {
                     userType: m.userType,
                 })),
             });
-            return error ? { error } : { members: results };
         });
     }
     // ============================================================================
@@ -291,17 +307,17 @@ export class LPClient {
     async getItem(itemId) {
         return this.cached(`item:${itemId}`, this.cacheTtl.itemsTtl, async () => {
             const url = this.workspaceUrl(`items/v1?${filterIs('id', itemId)}`);
-            const { data, error } = await this.fetchAndParse(url, async (r) => {
-                const result = await r.json();
-                if (!result.data || result.data.length === 0)
+            const result = await this.fetchAndParse(url, async (r) => {
+                const json = await r.json();
+                if (!json.data || json.data.length === 0)
                     return null;
-                return transformItem(result.data[0]);
+                return transformItem(json.data[0]);
             });
-            if (error)
-                return { error };
-            if (!data)
-                return { error: { message: `Item ${itemId} not found`, statusCode: 404 } };
-            return { item: data };
+            if (!result.ok)
+                return result;
+            if (!result.data)
+                return err(`Item ${itemId} not found`, 404);
+            return ok(result.data);
         });
     }
     /**
@@ -314,14 +330,13 @@ export class LPClient {
      */
     async getItems(itemIds) {
         if (itemIds.length === 0)
-            return { items: [] };
+            return ok([]);
         const baseUrl = this.workspaceUrl(`items/v1?${filterIn('id', itemIds)}`);
-        const { results, error } = await paginatedFetch({
+        return paginatedFetch({
             fetchFn: (url) => this.fetch(url),
             baseUrl,
             transform: (data) => data.map(transformItem),
         });
-        return error ? { error } : { items: results };
     }
     /**
      * Get the ancestry chain for an item
@@ -334,7 +349,7 @@ export class LPClient {
     async getItemAncestors(itemId) {
         return this.cached(`ancestors:${itemId}`, this.cacheTtl.itemsTtl, async () => {
             const url = this.workspaceUrl(`items/v1/${itemId}/ancestors`);
-            const { data, error } = await this.fetchAndParse(url, async (r) => {
+            return this.fetchAndParse(url, async (r) => {
                 const json = (await r.json());
                 // Handle both { data: [...] } and direct array responses
                 const rawData = Array.isArray(json) ? json : (json.data || []);
@@ -344,7 +359,6 @@ export class LPClient {
                     itemType: normalizeItemType(a.itemType),
                 })).reverse(); // LP API returns child→root, normalize to root→child
             }, { description: `Get ancestors for item ${itemId}` });
-            return error ? { error } : { ancestors: data };
         });
     }
     /**
@@ -353,12 +367,11 @@ export class LPClient {
     async findAssignments(taskId) {
         // parentId[is]="{taskId}"&itemType[is]="assignments" (LP API uses lowercase plural)
         const baseUrl = this.workspaceUrl(`items/v1?${filterIs('parentId', taskId)}&${filterIs('itemType', 'assignments')}`);
-        const { results, error } = await paginatedFetch({
+        return paginatedFetch({
             fetchFn: (url) => this.fetch(url),
             baseUrl,
             transform: (data) => data.map(transformItem),
         });
-        return error ? { error } : { assignments: results };
     }
     /**
      * Get all assignments for a specific member
@@ -369,13 +382,12 @@ export class LPClient {
     async getMyAssignments(memberId) {
         return this.cached(`assignments:${memberId}`, this.cacheTtl.assignmentsTtl, async () => {
             const baseUrl = this.workspaceUrl(`items/v1?${filterIs('itemType', 'assignments')}`);
-            const { results, error } = await paginatedFetch({
+            return paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
                 filter: (data) => data.filter(item => item.userId === memberId),
                 transform: (data) => data.map(transformItem),
             });
-            return error ? { error } : { assignments: results };
         });
     }
     /**
@@ -396,11 +408,12 @@ export class LPClient {
      */
     async getMyAssignmentsWithContext(memberId, options) {
         // 1. Get raw assignments
-        const { assignments, error } = await this.getMyAssignments(memberId);
-        if (error || !assignments)
-            return { error };
+        const assignResult = await this.getMyAssignments(memberId);
+        if (!assignResult.ok)
+            return assignResult;
+        const assignments = assignResult.data;
         if (assignments.length === 0)
-            return { assignments: [] };
+            return ok([]);
         // 2. Handle based on options
         let taskMap = new Map();
         let projectMap = new Map();
@@ -417,12 +430,12 @@ export class LPClient {
             }
             const parentEntries = [...assignmentsByParent.entries()];
             const ancestorResults = await batchMap(parentEntries, 5, async ([parentId, assignment]) => {
-                const { ancestors, error } = await this.getItemAncestors(assignment.id);
-                return { parentId, ancestors, error };
+                const result = await this.getItemAncestors(assignment.id);
+                return { parentId, ancestors: result.data, error: result.ok ? undefined : result };
             });
             const firstError = ancestorResults.find(r => r.error);
             if (firstError) {
-                return { error: firstError.error };
+                return firstError.error;
             }
             for (const { parentId, ancestors } of ancestorResults) {
                 ancestorMap.set(parentId, ancestors);
@@ -431,72 +444,70 @@ export class LPClient {
         else {
             // Original path: batch fetch tasks first
             const taskIds = [...new Set(assignments.map(a => a.parentId).filter((id) => id !== undefined))];
-            const { items: tasks, error: taskError } = await this.getItems(taskIds);
-            if (taskError)
-                return { error: taskError };
-            for (const task of tasks || []) {
+            const taskResult = await this.getItems(taskIds);
+            if (!taskResult.ok)
+                return taskResult;
+            for (const task of taskResult.data || []) {
                 taskMap.set(task.id, task);
             }
             if (options?.includeProject) {
                 // Also fetch grandparent projects
                 const projectIds = [...new Set([...taskMap.values()].map(t => t.parentId).filter((id) => id !== undefined))];
-                const { items: projects, error: projectError } = await this.getItems(projectIds);
-                if (projectError)
-                    return { error: projectError };
-                for (const project of projects || []) {
+                const projectResult = await this.getItems(projectIds);
+                if (!projectResult.ok)
+                    return projectResult;
+                for (const project of projectResult.data || []) {
                     projectMap.set(project.id, project);
                 }
             }
         }
         // 3. Merge context into assignments
-        return {
-            assignments: assignments.map(a => {
-                const result = { ...a };
-                if (options?.includeHierarchy && a.parentId) {
-                    // Full hierarchy mode - extract task name from ancestors
-                    const ancestors = ancestorMap.get(a.parentId);
-                    result.ancestors = ancestors;
-                    if (ancestors && ancestors.length > 0) {
-                        // Extract task name from first Task ancestor
-                        const taskAncestor = ancestors.find(anc => anc.itemType === 'Task');
-                        result.taskName = taskAncestor?.name ?? null;
-                        // Build hierarchyPath from Project and Folder ancestors
-                        // Exclude system containers (Package, WorkspaceRoot) and Tasks
-                        const hierarchyAncestors = ancestors
-                            .filter(anc => anc.itemType === 'Project' || anc.itemType === 'Folder');
-                        if (hierarchyAncestors.length > 0) {
-                            result.hierarchyPath = hierarchyAncestors
-                                .map(anc => anc.name ?? `[${anc.id}]`)
-                                .join(' › ');
-                            // Set projectId/projectName from root (first in reversed array)
-                            result.projectId = hierarchyAncestors[0].id;
-                            result.projectName = hierarchyAncestors[0].name;
-                        }
-                        else {
-                            result.projectName = null;
-                        }
+        return ok(assignments.map(a => {
+            const result = { ...a };
+            if (options?.includeHierarchy && a.parentId) {
+                // Full hierarchy mode - extract task name from ancestors
+                const ancestors = ancestorMap.get(a.parentId);
+                result.ancestors = ancestors;
+                if (ancestors && ancestors.length > 0) {
+                    // Extract task name from first Task ancestor
+                    const taskAncestor = ancestors.find(anc => anc.itemType === 'Task');
+                    result.taskName = taskAncestor?.name ?? null;
+                    // Build hierarchyPath from Project and Folder ancestors
+                    // Exclude system containers (Package, WorkspaceRoot) and Tasks
+                    const hierarchyAncestors = ancestors
+                        .filter(anc => anc.itemType === 'Project' || anc.itemType === 'Folder');
+                    if (hierarchyAncestors.length > 0) {
+                        result.hierarchyPath = hierarchyAncestors
+                            .map(anc => anc.name ?? `[${anc.id}]`)
+                            .join(' › ');
+                        // Set projectId/projectName from root (first in reversed array)
+                        result.projectId = hierarchyAncestors[0].id;
+                        result.projectName = hierarchyAncestors[0].name;
                     }
                     else {
-                        result.taskName = null;
                         result.projectName = null;
                     }
                 }
                 else {
-                    // Original path - use taskMap
-                    const task = a.parentId ? taskMap.get(a.parentId) : undefined;
-                    result.taskName = task?.name ?? null;
-                    if (options?.includeProject) {
-                        const project = task?.parentId ? projectMap.get(task.parentId) : undefined;
-                        result.projectId = project?.id;
-                        result.projectName = project?.name ?? null;
-                    }
-                    else {
-                        result.projectName = null;
-                    }
+                    result.taskName = null;
+                    result.projectName = null;
                 }
-                return result;
-            }),
-        };
+            }
+            else {
+                // Original path - use taskMap
+                const task = a.parentId ? taskMap.get(a.parentId) : undefined;
+                result.taskName = task?.name ?? null;
+                if (options?.includeProject) {
+                    const project = task?.parentId ? projectMap.get(task.parentId) : undefined;
+                    result.projectId = project?.id;
+                    result.projectName = project?.name ?? null;
+                }
+                else {
+                    result.projectName = null;
+                }
+            }
+            return result;
+        }));
     }
     // ============================================================================
     // Item Queries (Rich Filtering)
@@ -561,12 +572,11 @@ export class LPClient {
         }
         const query = filters.length > 0 ? `?${joinFilters(...filters)}` : '';
         const baseUrl = this.workspaceUrl(`items/v1${query}`);
-        const { results, error } = await paginatedFetch({
+        return paginatedFetch({
             fetchFn: (url) => this.fetch(url),
             baseUrl,
             transform: (data) => data.map(transformItem),
         });
-        return error ? { error } : { items: results };
     }
     /**
      * Get direct children of an item
@@ -601,11 +611,11 @@ export class LPClient {
     async getWorkspaceTree() {
         return this.cached('tree', this.cacheTtl.treeTtl, async () => {
             // Fetch all workspace items in paginated calls
-            const { items, error } = await this.findItems({});
-            if (error || !items)
-                return { error };
-            const tree = buildTree(items);
-            return { tree };
+            const result = await this.findItems({});
+            if (!result.ok)
+                return err(result.error, result.status);
+            const tree = buildTree(result.data);
+            return ok(tree);
         });
     }
     /**
@@ -620,9 +630,10 @@ export class LPClient {
      * @param memberId - The member ID to get work for
      */
     async getMyWork(memberId) {
-        const { tree, error } = await this.getWorkspaceTree();
-        if (error || !tree)
-            return { error };
+        const treeResult = await this.getWorkspaceTree();
+        if (!treeResult.ok)
+            return err(treeResult.error, treeResult.status);
+        const tree = treeResult.data;
         const assignments = [];
         for (const node of tree.byId.values()) {
             if (node.itemType !== 'Assignment' || node.userId !== memberId)
@@ -646,7 +657,7 @@ export class LPClient {
             }
             assignments.push(result);
         }
-        return { assignments, treeItemCount: tree.itemCount };
+        return ok({ assignments, treeItemCount: tree.itemCount });
     }
     // ============================================================================
     // Cost Codes
@@ -657,7 +668,7 @@ export class LPClient {
     async getCostCodes() {
         return this.cached('costcodes', this.cacheTtl.costCodesTtl, async () => {
             const baseUrl = this.workspaceUrl('cost-codes/v1');
-            const { results, error } = await paginatedFetch({
+            return paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
                 transform: (data) => data.map(cc => ({
@@ -666,7 +677,6 @@ export class LPClient {
                     billable: cc.billable,
                 })),
             });
-            return error ? { error } : { costCodes: results };
         });
     }
     // ============================================================================
@@ -695,15 +705,11 @@ export class LPClient {
         if (note) {
             body.note = note;
         }
-        const { data, error } = await this.fetchAndParse(url, async (r) => {
+        return this.fetchAndParseMutation(url, async (r) => {
             this.cache?.invalidate('timesheet:');
             const result = await r.json();
             return result.id;
         }, { method: 'POST', body });
-        if (error) {
-            return { success: false, error: error.message, statusCode: error.statusCode, isDuplicate: error.isDuplicate };
-        }
-        return { success: true, entryId: data };
     }
     /**
      * Get timesheet entries for one or more dates
@@ -730,7 +736,7 @@ export class LPClient {
             if (itemId) {
                 baseUrl += `&${filterIs('itemId', itemId)}`;
             }
-            const { results, error } = await paginatedFetch({
+            return paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
                 transform: (data) => data.map(entry => ({
@@ -743,7 +749,6 @@ export class LPClient {
                     userId: entry.userId,
                 })),
             });
-            return error ? { error } : { entries: results };
         });
     }
     /**
@@ -779,13 +784,10 @@ export class LPClient {
             note: updates.note ?? '',
             userId: existingEntry.userId,
         };
-        const { error } = await this.fetchAndParse(url, async () => {
+        return this.fetchAndParseMutation(url, async () => {
             this.cache?.invalidate('timesheet:');
+            return entryId;
         }, { method: 'PUT', body });
-        if (error) {
-            return { success: false, error: error.message, statusCode: error.statusCode, isDuplicate: error.isDuplicate };
-        }
-        return { success: true, entryId };
     }
     /**
      * Create or update a timesheet entry (upsert)
@@ -824,14 +826,14 @@ export class LPClient {
     async upsertTimesheetEntry(entry, options = {}) {
         const { accumulate = true } = options;
         // Fetch existing entries for this date/item first
-        const { entries, error: fetchError } = await this.getTimesheetEntries(entry.date, entry.itemId);
-        if (fetchError) {
-            return { success: false, error: fetchError.message, statusCode: fetchError.statusCode };
+        const fetchResult = await this.getTimesheetEntries(entry.date, entry.itemId);
+        if (!fetchResult.ok) {
+            return { ok: false, error: fetchResult.error, status: fetchResult.status };
         }
         // Find matching entry
         // If no costCodeId specified, match any entry (LP uses assignment's default)
         // If costCodeId specified, match exactly
-        const existingEntry = entries?.find((e) => {
+        const existingEntry = fetchResult.data?.find((e) => {
             if (entry.costCodeId === undefined || entry.costCodeId === null) {
                 return true;
             }

package/dist/errors.d.ts

@@ -28,12 +28,12 @@ export declare function parseLPErrorResponse(errorText: string, statusCode: numb
  */
 export declare class LPError extends Error {
     /** HTTP status code */
-    statusCode: number;
+    status: number;
     /** Whether this is a duplicate entry error */
     isDuplicate: boolean;
     /** Raw error response */
     rawResponse?: string;
-    constructor(message: string, statusCode: number, options?: {
+    constructor(message: string, status: number, options?: {
         isDuplicate?: boolean;
         rawResponse?: string;
     });

package/dist/errors.js

@@ -6,6 +6,7 @@
  * - {"message":"..."} or {"error":"..."}
  * - Plain text
  */
+import { parseJsonErrorResponse } from '@markwharton/api-core';
 /** Error code for duplicate entry errors */
 const LP_ERROR_CODE_DUPLICATE = 'duplicate_value';
 /**
@@ -25,10 +26,8 @@ export function parseLPErrorResponse(errorText, statusCode) {
             const message = firstError?.detail || firstError?.title || `HTTP ${statusCode}`;
             return { message, isDuplicate };
         }
-        // Fallback to message/error fields
-        return {
-            message: errorJson.message || errorJson.error || `HTTP ${statusCode}`,
-        };
+        // Fallback to common JSON error formats via api-core
+        return parseJsonErrorResponse(errorText, statusCode);
     }
     catch {
         // Not JSON, return as-is or fallback
@@ -39,10 +38,10 @@ export function parseLPErrorResponse(errorText, statusCode) {
  * Custom error class for LP API errors
  */
 export class LPError extends Error {
-    constructor(message, statusCode, options) {
+    constructor(message, status, options) {
         super(message);
         this.name = 'LPError';
-        this.statusCode = statusCode;
+        this.status = status;
         this.isDuplicate = options?.isDuplicate ?? false;
         this.rawResponse = options?.rawResponse;
     }

package/dist/index.d.ts

@@ -10,10 +10,12 @@
  * const client = new LPClient({ apiToken: 'xxx', workspaceId: 123 });
  *
  * // Validate credentials
- * await client.validateToken();
+ * const result = await client.validateToken();
+ * if (!result.ok) { console.error(result.error); }
  *
  * // Get workspaces
- * const { workspaces } = await client.getWorkspaces();
+ * const wsResult = await client.getWorkspaces();
+ * const workspaces = wsResult.data;
  *
  * // Resolve task to assignment
  * const resolution = await resolveTaskToAssignment(client, taskId, memberId);
@@ -28,11 +30,12 @@
  */
 export { LPClient } from './client.js';
 export { resolveTaskToAssignment } from './workflows.js';
-export type { LPConfig, LPCacheConfig, LPRetryConfig, LPItemType, HierarchyItem, LPItem, LPAncestor, LPWorkspace, LPMember, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPTaskResolution, LPResult, LPUpsertOptions, LPAssignmentWithContext, LPErrorInfo, LPFindItemsOptions, LPTreeNode, LPWorkspaceTree, } from './types.js';
+export type { LPConfig, LPCacheConfig, LPRetryConfig, LPItemType, HierarchyItem, LPItem, LPAncestor, LPWorkspace, LPMember, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPTaskResolution, LPUpsertOptions, LPAssignmentWithContext, LPFindItemsOptions, LPTreeNode, LPWorkspaceTree, } from './types.js';
+export { ok, err, getErrorMessage } from '@markwharton/api-core';
+export type { Result, RetryConfig } from '@markwharton/api-core';
 export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIsNot, filterIn, filterGt, filterLt, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
 export type { PaginateOptions } from './utils.js';
 export { buildTree, getTreeAncestors, getTreeHierarchyPath, findInTree, } from './tree.js';
-export { getErrorMessage } from '@markwharton/api-core';
 export { LP_API_BASE } from './constants.js';
 export { LPError, parseLPErrorResponse } from './errors.js';
 export type { LPParsedError } from './errors.js';

package/dist/index.js

@@ -10,10 +10,12 @@
  * const client = new LPClient({ apiToken: 'xxx', workspaceId: 123 });
  *
  * // Validate credentials
- * await client.validateToken();
+ * const result = await client.validateToken();
+ * if (!result.ok) { console.error(result.error); }
  *
  * // Get workspaces
- * const { workspaces } = await client.getWorkspaces();
+ * const wsResult = await client.getWorkspaces();
+ * const workspaces = wsResult.data;
  *
  * // Resolve task to assignment
  * const resolution = await resolveTaskToAssignment(client, taskId, memberId);
@@ -30,11 +32,12 @@
 export { LPClient } from './client.js';
 // Workflows
 export { resolveTaskToAssignment } from './workflows.js';
+// Re-export Result from api-core
+export { ok, err, getErrorMessage } from '@markwharton/api-core';
 // Utilities
 export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIsNot, filterIn, filterGt, filterLt, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
 // Tree utilities
 export { buildTree, getTreeAncestors, getTreeHierarchyPath, findInTree, } from './tree.js';
-export { getErrorMessage } from '@markwharton/api-core';
 // Constants
 export { LP_API_BASE } from './constants.js';
 // Errors

package/dist/types.d.ts

@@ -4,6 +4,7 @@
  * These types define the data structures used when interacting with
  * the LiquidPlanner API.
  */
+import type { Result, RetryConfig } from '@markwharton/api-core';
 /**
  * LiquidPlanner item types in the hierarchy
  */
@@ -192,18 +193,9 @@ export interface LPCacheConfig {
 /**
  * Retry configuration for LPClient
  *
- * Controls automatic retry behavior for transient failures
- * (HTTP 429 Too Many Requests, 503 Service Unavailable).
- * Uses exponential backoff with optional Retry-After header support.
+ * @deprecated Use RetryConfig from @markwharton/api-core instead
  */
-export interface LPRetryConfig {
-    /** Maximum number of retry attempts (default: 3) */
-    maxRetries?: number;
-    /** Initial delay in milliseconds before first retry (default: 1000) */
-    initialDelayMs?: number;
-    /** Maximum delay cap in milliseconds (default: 10000) */
-    maxDelayMs?: number;
-}
+export type LPRetryConfig = RetryConfig;
 /**
  * LiquidPlanner configuration for API access
  */
@@ -227,16 +219,10 @@ export interface LPConfig {
 }
 /**
  * Result of a timesheet sync operation
+ *
+ * Extends Result<number> where data is the entry ID.
  */
-export interface LPSyncResult {
-    /** Whether the operation succeeded */
-    success: boolean;
-    /** ID of the created entry (if successful) */
-    entryId?: number;
-    /** Error message (if failed) */
-    error?: string;
-    /** HTTP status code (if failed) - useful for detecting rate limits (429) */
-    statusCode?: number;
+export interface LPSyncResult extends Result<number> {
     /** Whether the error was due to a duplicate entry */
     isDuplicate?: boolean;
 }
@@ -264,15 +250,6 @@ export interface LPTimesheetEntryWithId extends LPTimesheetEntry {
     /** User ID who logged the time */
     userId?: number;
 }
-/**
- * Generic result wrapper for LP operations
- */
-export interface LPResult<T> {
-    /** The data if successful */
-    data?: T;
-    /** Error message if failed */
-    error?: string;
-}
 /**
  * Options for upsert timesheet entry operation
  */
@@ -302,19 +279,6 @@ export interface LPAssignmentWithContext extends LPItem {
     /** Formatted hierarchy path like "Project A › Subfolder B" (undefined if not requested) */
     hierarchyPath?: string;
 }
-/**
- * Structured error information from LP API
- *
- * Preserves HTTP status code for proper error handling (e.g., 429 rate limits).
- */
-export interface LPErrorInfo {
-    /** Human-readable error message */
-    message: string;
-    /** HTTP status code from the response */
-    statusCode: number;
-    /** Whether this error indicates a duplicate entry */
-    isDuplicate?: boolean;
-}
 /**
  * Options for querying items with LP API filters
  *

package/dist/utils.d.ts

@@ -1,7 +1,8 @@
 /**
  * LiquidPlanner Utility Functions
  */
-import type { LPItemType, LPErrorInfo } from './types.js';
+import type { LPItemType } from './types.js';
+import type { Result } from '@markwharton/api-core';
 /**
  * Build a URL-encoded filter for LP API: field[is]="value"
  */
@@ -56,10 +57,7 @@ export interface PaginateOptions<TRaw, TResult> {
  *
  * Handles the continuation token pattern used by LP API.
  */
-export declare function paginatedFetch<TRaw, TResult>(options: PaginateOptions<TRaw, TResult>): Promise<{
-    results?: TResult[];
-    error?: LPErrorInfo;
-}>;
+export declare function paginatedFetch<TRaw, TResult>(options: PaginateOptions<TRaw, TResult>): Promise<Result<TResult[]>>;
 /**
  * Convert decimal hours to minutes
  *

package/dist/utils.js

@@ -2,7 +2,7 @@
  * LiquidPlanner Utility Functions
  */
 import { parseLPErrorResponse } from './errors.js';
-import { getErrorMessage } from '@markwharton/api-core';
+import { getErrorMessage, err } from '@markwharton/api-core';
 // ============================================================================
 // LP API Filter Builders
 // ============================================================================
@@ -88,8 +88,8 @@ export async function paginatedFetch(options) {
             const response = await fetchFn(url);
             if (!response.ok) {
                 const errorText = await response.text();
-                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
-                return { error: { message, statusCode: response.status, isDuplicate } };
+                const { message } = parseLPErrorResponse(errorText, response.status);
+                return err(message, response.status);
             }
             const result = await response.json();
             const rawData = result.data || [];
@@ -98,11 +98,11 @@ export async function paginatedFetch(options) {
             allResults.push(...pageResults);
             continuationToken = result.continuationToken;
         } while (continuationToken);
-        return { results: allResults };
+        return { ok: true, data: allResults };
     }
     catch (error) {
         // Network errors or JSON parse errors don't have HTTP status codes
-        return { error: { message: getErrorMessage(error), statusCode: 0 } };
+        return err(getErrorMessage(error), 0);
     }
 }
 /**

package/dist/workflows.js

@@ -37,14 +37,15 @@
  */
 export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
     // Step 1: Fetch the item
-    const { item, error: fetchError } = await client.getItem(itemId);
-    if (fetchError || !item) {
+    const itemResult = await client.getItem(itemId);
+    if (!itemResult.ok || !itemResult.data) {
         return {
             inputItem: { id: itemId, name: null, itemType: 'Task' },
             assignmentId: 0,
-            error: fetchError?.message || 'Item not found',
+            error: itemResult.error || 'Item not found',
         };
     }
+    const item = itemResult.data;
     // Step 2: Check item type and resolve accordingly
     switch (item.itemType) {
         case 'Assignment':
@@ -57,14 +58,15 @@ export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
             };
         case 'Task': {
             // Find assignments under this task
-            const { assignments, error: assignmentError } = await client.findAssignments(item.id);
-            if (assignmentError) {
+            const assignResult = await client.findAssignments(item.id);
+            if (!assignResult.ok) {
                 return {
                     inputItem: item,
                     assignmentId: 0,
-                    error: `Failed to find assignments: ${assignmentError.message}`,
+                    error: `Failed to find assignments: ${assignResult.error}`,
                 };
             }
+            const assignments = assignResult.data;
             if (!assignments || assignments.length === 0) {
                 return {
                     inputItem: item,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markwharton/liquidplanner",
-  "version": "1.12.0",
+  "version": "2.0.0",
   "description": "LiquidPlanner API client for timesheet integration",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@markwharton/api-core": "^1.0.0"
+    "@markwharton/api-core": "^1.1.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

package/dist/cache.d.ts

@@ -1,43 +0,0 @@
-/**
- * Simple in-memory TTL cache with request coalescing
- *
- * Provides per-instance memoization for LPClient API responses.
- * In serverless environments (Azure Functions, Static Web Apps),
- * module-level state persists across warm invocations within the
- * same instance — this cache leverages that behavior.
- *
- * Request coalescing: when multiple concurrent callers request the
- * same expired key, only one factory call is made. All callers
- * receive the same resolved value (or the same rejection).
- *
- * Not a distributed cache: each instance has its own cache.
- * Cold starts and instance recycling naturally clear stale data.
- */
-export declare class TTLCache {
-    private store;
-    private inflight;
-    /**
-     * Get a cached value, or call the factory to populate it.
-     *
-     * If a factory call is already in progress for this key,
-     * returns the existing promise instead of starting a duplicate.
-     *
-     * @param key - Cache key
-     * @param ttlMs - Time-to-live in milliseconds
-     * @param factory - Async function to produce the value on cache miss
-     */
-    get<T>(key: string, ttlMs: number, factory: () => Promise<T>): Promise<T>;
-    /**
-     * Invalidate cache entries matching a key prefix.
-     *
-     * Also cancels any in-flight requests for matching keys,
-     * so subsequent calls will start fresh factory invocations.
-     *
-     * Example: invalidate('timesheet:') clears all timesheet entries.
-     */
-    invalidate(prefix: string): void;
-    /**
-     * Clear all cached data and in-flight requests.
-     */
-    clear(): void;
-}

package/dist/cache.js

@@ -1,78 +0,0 @@
-/**
- * Simple in-memory TTL cache with request coalescing
- *
- * Provides per-instance memoization for LPClient API responses.
- * In serverless environments (Azure Functions, Static Web Apps),
- * module-level state persists across warm invocations within the
- * same instance — this cache leverages that behavior.
- *
- * Request coalescing: when multiple concurrent callers request the
- * same expired key, only one factory call is made. All callers
- * receive the same resolved value (or the same rejection).
- *
- * Not a distributed cache: each instance has its own cache.
- * Cold starts and instance recycling naturally clear stale data.
- */
-export class TTLCache {
-    constructor() {
-        this.store = new Map();
-        this.inflight = new Map();
-    }
-    /**
-     * Get a cached value, or call the factory to populate it.
-     *
-     * If a factory call is already in progress for this key,
-     * returns the existing promise instead of starting a duplicate.
-     *
-     * @param key - Cache key
-     * @param ttlMs - Time-to-live in milliseconds
-     * @param factory - Async function to produce the value on cache miss
-     */
-    async get(key, ttlMs, factory) {
-        const existing = this.store.get(key);
-        if (existing && existing.expiresAt > Date.now()) {
-            return existing.data;
-        }
-        const pending = this.inflight.get(key);
-        if (pending) {
-            return pending;
-        }
-        const promise = factory().then((data) => {
-            this.store.set(key, { data, expiresAt: Date.now() + ttlMs });
-            this.inflight.delete(key);
-            return data;
-        }, (err) => {
-            this.inflight.delete(key);
-            throw err;
-        });
-        this.inflight.set(key, promise);
-        return promise;
-    }
-    /**
-     * Invalidate cache entries matching a key prefix.
-     *
-     * Also cancels any in-flight requests for matching keys,
-     * so subsequent calls will start fresh factory invocations.
-     *
-     * Example: invalidate('timesheet:') clears all timesheet entries.
-     */
-    invalidate(prefix) {
-        for (const key of this.store.keys()) {
-            if (key.startsWith(prefix)) {
-                this.store.delete(key);
-            }
-        }
-        for (const key of this.inflight.keys()) {
-            if (key.startsWith(prefix)) {
-                this.inflight.delete(key);
-            }
-        }
-    }
-    /**
-     * Clear all cached data and in-flight requests.
-     */
-    clear() {
-        this.store.clear();
-        this.inflight.clear();
-    }
-}