@markwharton/liquidplanner 1.11.0 → 2.0.0

package/dist/client.js

@@ -6,10 +6,11 @@
  *
  * @see https://api-docs.liquidplanner.com/
  */
-import { buildAuthHeader, hoursToMinutes, normalizeItemType, filterIs, filterIn, paginatedFetch, } from './utils.js';
+import { buildAuthHeader, hoursToMinutes, normalizeItemType, filterIs, filterIsNot, filterIn, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
+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 = {
@@ -63,6 +64,25 @@ function transformItem(raw) {
         item.folderStatus = raw.folderStatus;
     if (raw.globalPriority)
         item.globalPriority = raw.globalPriority;
+    // Extended fields — only include if present
+    if (raw.color)
+        item.color = raw.color;
+    if (raw.workType)
+        item.workType = raw.workType;
+    if (raw.description)
+        item.description = raw.description;
+    if (raw.customFieldValues)
+        item.customFieldValues = raw.customFieldValues;
+    if (raw.createdAt)
+        item.createdAt = raw.createdAt;
+    if (raw.updatedAt)
+        item.updatedAt = raw.updatedAt;
+    if (raw.clippedHours !== undefined)
+        item.clippedHours = raw.clippedHours;
+    if (raw.workLimitHours !== undefined)
+        item.workLimitHours = raw.workLimitHours;
+    if (raw.workLimitRisk !== undefined)
+        item.workLimitRisk = raw.workLimitRisk;
     return item;
 }
 /**
@@ -103,6 +123,7 @@ export class LPClient {
             timesheetTtl: config.cache?.timesheetTtl ?? 60000,
             assignmentsTtl: config.cache?.assignmentsTtl ?? 120000,
             itemsTtl: config.cache?.itemsTtl ?? 300000,
+            treeTtl: config.cache?.treeTtl ?? 600000,
         };
         // Initialize retry config with defaults if provided
         if (config.retry) {
@@ -145,6 +166,13 @@ export class LPClient {
     invalidateAssignmentsCache() {
         this.cache?.invalidate('assignments:');
     }
+    /**
+     * Invalidate cached workspace tree snapshot only.
+     * Use when the workspace structure changes (items created, moved, or deleted).
+     */
+    invalidateTreeCache() {
+        this.cache?.invalidate('tree');
+    }
     /**
      * Make an authenticated request to the LP API
      *
@@ -189,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 };
         }
     }
     // ============================================================================
@@ -208,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');
         }
     }
     /**
@@ -224,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
@@ -239,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 => ({
@@ -251,7 +296,6 @@ export class LPClient {
                     userType: m.userType,
                 })),
             });
-            return error ? { error } : { members: results };
         });
     }
     // ============================================================================
@@ -263,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);
         });
     }
     /**
@@ -286,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
@@ -306,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 || []);
@@ -316,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 };
         });
     }
     /**
@@ -325,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
@@ -341,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 };
         });
     }
     /**
@@ -368,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();
@@ -389,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);
@@ -403,72 +444,220 @@ 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)
+    // ============================================================================
+    /**
+     * Query items with LP API filters
+     *
+     * General-purpose method that exposes the full filtering capabilities of
+     * the LP items endpoint. Not cached — use higher-level methods like
+     * getWorkspaceTree() for cached access.
+     *
+     * @see https://api-docs.liquidplanner.com/docs/plan-items
+     *
+     * @param options - Filter options (all optional, combined with AND)
+     */
+    async findItems(options) {
+        const filters = [];
+        // Identity
+        if (options.parentId !== undefined)
+            filters.push(filterIs('parentId', options.parentId));
+        if (options.itemType)
+            filters.push(filterIs('itemType', options.itemType));
+        // Status
+        if (options.taskStatusGroup)
+            filters.push(filterIs('taskStatusGroup', options.taskStatusGroup));
+        if (options.taskStatusGroupNot)
+            filters.push(filterIsNot('taskStatusGroup', options.taskStatusGroupNot));
+        if (options.taskStatusId !== undefined)
+            filters.push(filterIs('taskStatusId', options.taskStatusId));
+        if (options.packageStatus)
+            filters.push(filterIs('packageStatus', options.packageStatus));
+        if (options.folderStatus)
+            filters.push(filterIs('folderStatus', options.folderStatus));
+        // Scheduling
+        if (options.scheduleDirective)
+            filters.push(filterIs('scheduleDirective', options.scheduleDirective));
+        if (options.expectedStartAfter)
+            filters.push(filterAfter('expectedStart', options.expectedStartAfter));
+        if (options.expectedFinishBefore)
+            filters.push(filterBefore('expectedFinish', options.expectedFinishBefore));
+        if (options.targetStartAfter)
+            filters.push(filterAfter('targetStart', options.targetStartAfter));
+        if (options.targetFinishBefore)
+            filters.push(filterBefore('targetFinish', options.targetFinishBefore));
+        if (options.doneDateAfter)
+            filters.push(filterAfter('doneDate', options.doneDateAfter));
+        // Flags
+        if (options.late !== undefined)
+            filters.push(filterIs('late', String(options.late)));
+        if (options.workLimitRisk !== undefined)
+            filters.push(filterIs('workLimitRisk', String(options.workLimitRisk)));
+        if (options.hasFiles !== undefined)
+            filters.push(filterIs('hasFiles', String(options.hasFiles)));
+        // Search
+        if (options.name)
+            filters.push(filterIs('name', options.name));
+        // Custom fields
+        if (options.customFieldValues) {
+            for (const [key, value] of Object.entries(options.customFieldValues)) {
+                filters.push(filterIs(`customFieldValues.${key}`, value));
+            }
+        }
+        const query = filters.length > 0 ? `?${joinFilters(...filters)}` : '';
+        const baseUrl = this.workspaceUrl(`items/v1${query}`);
+        return paginatedFetch({
+            fetchFn: (url) => this.fetch(url),
+            baseUrl,
+            transform: (data) => data.map(transformItem),
+        });
+    }
+    /**
+     * Get direct children of an item
+     *
+     * Uses parentId[is] filter to fetch immediate descendants.
+     * Optionally filter by item type.
+     *
+     * @param parentId - The parent item ID
+     * @param options - Optional item type filter
+     */
+    async getChildren(parentId, options) {
+        return this.findItems({
+            parentId,
+            itemType: options?.itemType,
+        });
+    }
+    // ============================================================================
+    // Workspace Tree
+    // ============================================================================
+    /**
+     * Fetch a snapshot of the active workspace tree
+     *
+     * Fetches all workspace items in paginated API calls, then builds a
+     * navigable tree in memory from parentId relationships.
+     *
+     * The result is cached with treeTtl (default: 10 minutes).
+     * Use invalidateTreeCache() to force a refresh.
+     *
+     * After the initial fetch, all hierarchy queries (ancestors, paths, assignments
+     * with context) can be answered from the cached tree with zero API calls.
+     */
+    async getWorkspaceTree() {
+        return this.cached('tree', this.cacheTtl.treeTtl, async () => {
+            // Fetch all workspace items in paginated calls
+            const result = await this.findItems({});
+            if (!result.ok)
+                return err(result.error, result.status);
+            const tree = buildTree(result.data);
+            return ok(tree);
+        });
+    }
+    /**
+     * Get a member's active work with full context from the workspace tree
+     *
+     * This is the optimized alternative to getMyAssignmentsWithContext().
+     * Uses the workspace tree snapshot (cached) to resolve hierarchy locally,
+     * eliminating the N+1 ancestor request pattern.
+     *
+     * API calls: 0 (if tree cached) or 1-3 (cold load)
+     *
+     * @param memberId - The member ID to get work for
+     */
+    async getMyWork(memberId) {
+        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)
+                continue;
+            const ancestors = getTreeAncestors(tree, node.id);
+            const taskAncestor = ancestors.find(a => a.itemType === 'Task');
+            const hierarchyAncestors = ancestors.filter(a => a.itemType === 'Project' || a.itemType === 'Folder');
+            const { children: _, ...itemFields } = node;
+            const result = { ...itemFields };
+            result.taskName = taskAncestor?.name ?? null;
+            result.ancestors = ancestors;
+            if (hierarchyAncestors.length > 0) {
+                result.projectId = hierarchyAncestors[0].id;
+                result.projectName = hierarchyAncestors[0].name;
+                result.hierarchyPath = hierarchyAncestors
+                    .map(a => a.name ?? `[${a.id}]`)
+                    .join(' › ');
+            }
+            else {
+                result.projectName = null;
+            }
+            assignments.push(result);
+        }
+        return ok({ assignments, treeItemCount: tree.itemCount });
     }
     // ============================================================================
     // Cost Codes
@@ -479,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 => ({
@@ -488,7 +677,6 @@ export class LPClient {
                     billable: cc.billable,
                 })),
             });
-            return error ? { error } : { costCodes: results };
         });
     }
     // ============================================================================
@@ -517,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
@@ -552,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 => ({
@@ -565,7 +749,6 @@ export class LPClient {
                     userId: entry.userId,
                 })),
             });
-            return error ? { error } : { entries: results };
         });
     }
     /**
@@ -601,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)
@@ -646,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;
     }