@markwharton/liquidplanner 1.4.0 → 1.5.0

package/dist/client.d.ts

@@ -6,7 +6,7 @@
  *
  * @see https://api-docs.liquidplanner.com/
  */
-import type { LPConfig, LPWorkspace, LPMember, LPItem, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPUpsertOptions, LPAssignmentWithContext, LPAncestor } from './types.js';
+import type { LPConfig, LPWorkspace, LPMember, LPItem, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPUpsertOptions, LPAssignmentWithContext, LPAncestor, LPErrorInfo } from './types.js';
 /**
  * LiquidPlanner API Client
  *
@@ -51,21 +51,21 @@ export declare class LPClient {
      */
     getWorkspaces(): Promise<{
         workspaces?: LPWorkspace[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Get all members in the workspace (with pagination)
      */
     getWorkspaceMembers(): Promise<{
         members?: LPMember[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Get a single item by ID
      */
     getItem(itemId: number): Promise<{
         item?: LPItem;
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Get multiple items by ID in a single request (batch fetch)
@@ -77,7 +77,7 @@ export declare class LPClient {
      */
     getItems(itemIds: number[]): Promise<{
         items?: LPItem[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Get the ancestry chain for an item
@@ -89,14 +89,14 @@ export declare class LPClient {
      */
     getItemAncestors(itemId: number): Promise<{
         ancestors?: LPAncestor[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Find all assignments under a task (with pagination)
      */
     findAssignments(taskId: number): Promise<{
         assignments?: LPItem[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Get all assignments for a specific member
@@ -106,7 +106,7 @@ export declare class LPClient {
      */
     getMyAssignments(memberId: number): Promise<{
         assignments?: LPItem[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Get assignments for a member with parent task names resolved
@@ -129,14 +129,14 @@ export declare class LPClient {
         includeHierarchy?: boolean;
     }): Promise<{
         assignments?: LPAssignmentWithContext[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Get all cost codes in the workspace (with pagination)
      */
     getCostCodes(): Promise<{
         costCodes?: LPCostCode[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Create a timesheet entry (log time)
@@ -158,7 +158,7 @@ export declare class LPClient {
      */
     getTimesheetEntries(date: string, itemId?: number): Promise<{
         entries?: LPTimesheetEntryWithId[];
-        error?: string;
+        error?: LPErrorInfo;
     }>;
     /**
      * Update an existing timesheet entry

package/dist/client.js

@@ -96,8 +96,8 @@ export class LPClient {
             const response = await this.fetch(url);
             if (!response.ok) {
                 const errorText = await response.text();
-                const { message } = parseLPErrorResponse(errorText, response.status);
-                return { error: message };
+                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
+                return { error: { message, statusCode: response.status, isDuplicate } };
             }
             const result = await response.json();
             const workspaces = (result.data || []).map(ws => ({
@@ -107,7 +107,7 @@ export class LPClient {
             return { workspaces };
         }
         catch (error) {
-            return { error: getErrorMessage(error) };
+            return { error: { message: getErrorMessage(error), statusCode: 0 } };
         }
     }
     // ============================================================================
@@ -144,17 +144,17 @@ export class LPClient {
             const response = await this.fetch(url);
             if (!response.ok) {
                 const errorText = await response.text();
-                const { message } = parseLPErrorResponse(errorText, response.status);
-                return { error: message };
+                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
+                return { error: { message, statusCode: response.status, isDuplicate } };
             }
             const result = await response.json();
             if (!result.data || result.data.length === 0) {
-                return { error: `Item ${itemId} not found` };
+                return { error: { message: `Item ${itemId} not found`, statusCode: 404 } };
             }
             return { item: transformItem(result.data[0]) };
         }
         catch (error) {
-            return { error: getErrorMessage(error) };
+            return { error: { message: getErrorMessage(error), statusCode: 0 } };
         }
     }
     /**
@@ -192,8 +192,8 @@ export class LPClient {
             });
             if (!response.ok) {
                 const errorText = await response.text();
-                const { message } = parseLPErrorResponse(errorText, response.status);
-                return { error: message };
+                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
+                return { error: { message, statusCode: response.status, isDuplicate } };
             }
             const json = (await response.json());
             // Handle both { data: [...] } and direct array responses
@@ -206,7 +206,7 @@ export class LPClient {
             return { ancestors };
         }
         catch (error) {
-            return { error: getErrorMessage(error) };
+            return { error: { message: getErrorMessage(error), statusCode: 0 } };
         }
     }
     /**
@@ -276,9 +276,13 @@ export class LPClient {
                 }
             }
             const ancestorResults = await Promise.all([...assignmentsByParent.entries()].map(async ([parentId, assignment]) => {
-                const { ancestors } = await this.getItemAncestors(assignment.id);
-                return { parentId, ancestors };
+                const { ancestors, error } = await this.getItemAncestors(assignment.id);
+                return { parentId, ancestors, error };
             }));
+            const firstError = ancestorResults.find(r => r.error);
+            if (firstError) {
+                return { error: firstError.error };
+            }
             for (const { parentId, ancestors } of ancestorResults) {
                 ancestorMap.set(parentId, ancestors);
             }
@@ -404,13 +408,13 @@ export class LPClient {
             if (!response.ok) {
                 const errorText = await response.text();
                 const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
-                return { success: false, error: message, isDuplicate };
+                return { success: false, error: message, statusCode: response.status, isDuplicate };
             }
             const result = await response.json();
             return { success: true, entryId: result.id };
         }
         catch (error) {
-            return { success: false, error: getErrorMessage(error) };
+            return { success: false, error: getErrorMessage(error), statusCode: 0 };
         }
     }
     /**
@@ -484,12 +488,12 @@ export class LPClient {
             if (!response.ok) {
                 const errorText = await response.text();
                 const { message } = parseLPErrorResponse(errorText, response.status);
-                return { success: false, error: message };
+                return { success: false, error: message, statusCode: response.status };
             }
             return { success: true, entryId };
         }
         catch (error) {
-            return { success: false, error: getErrorMessage(error) };
+            return { success: false, error: getErrorMessage(error), statusCode: 0 };
         }
     }
     /**
@@ -531,7 +535,7 @@ export class LPClient {
         // 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 };
+            return { success: false, error: fetchError.message, statusCode: fetchError.statusCode };
         }
         // Find matching entry
         // If no costCodeId specified, match any entry (LP uses assignment's default)

package/dist/index.d.ts

@@ -28,7 +28,7 @@
  */
 export { LPClient } from './client.js';
 export { resolveTaskToAssignment } from './workflows.js';
-export type { LPConfig, LPItemType, LPItem, LPAncestor, LPWorkspace, LPMember, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPTaskResolution, LPResult, LPUpsertOptions, LPAssignmentWithContext, } from './types.js';
+export type { LPConfig, LPItemType, LPItem, LPAncestor, LPWorkspace, LPMember, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetEntryWithId, LPTaskResolution, LPResult, LPUpsertOptions, LPAssignmentWithContext, LPErrorInfo, } from './types.js';
 export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIn, paginatedFetch, } from './utils.js';
 export type { PaginateOptions } from './utils.js';
 export { LP_API_BASE } from './constants.js';

package/dist/types.d.ts

@@ -119,6 +119,8 @@ export interface LPSyncResult {
     entryId?: number;
     /** Error message (if failed) */
     error?: string;
+    /** HTTP status code (if failed) - useful for detecting rate limits (429) */
+    statusCode?: number;
     /** Whether the error was due to a duplicate entry */
     isDuplicate?: boolean;
 }
@@ -184,3 +186,16 @@ 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;
+}

package/dist/utils.d.ts

@@ -1,7 +1,7 @@
 /**
  * LiquidPlanner Utility Functions
  */
-import type { LPItemType } from './types.js';
+import type { LPItemType, LPErrorInfo } from './types.js';
 /**
  * Build a URL-encoded filter for LP API: field[is]="value"
  */
@@ -30,7 +30,7 @@ export interface PaginateOptions<TRaw, TResult> {
  */
 export declare function paginatedFetch<TRaw, TResult>(options: PaginateOptions<TRaw, TResult>): Promise<{
     results?: TResult[];
-    error?: string;
+    error?: LPErrorInfo;
 }>;
 /**
  * Convert decimal hours to minutes

package/dist/utils.js

@@ -36,8 +36,8 @@ export async function paginatedFetch(options) {
             const response = await fetchFn(url);
             if (!response.ok) {
                 const errorText = await response.text();
-                const { message } = parseLPErrorResponse(errorText, response.status);
-                return { error: message };
+                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
+                return { error: { message, statusCode: response.status, isDuplicate } };
             }
             const result = await response.json();
             const rawData = result.data || [];
@@ -49,7 +49,8 @@ export async function paginatedFetch(options) {
         return { results: allResults };
     }
     catch (error) {
-        return { error: getErrorMessage(error) };
+        // Network errors or JSON parse errors don't have HTTP status codes
+        return { error: { message: getErrorMessage(error), statusCode: 0 } };
     }
 }
 /**

package/dist/workflows.js

@@ -42,7 +42,7 @@ export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
         return {
             inputItem: { id: itemId, name: null, itemType: 'Task' },
             assignmentId: 0,
-            error: fetchError || 'Item not found',
+            error: fetchError?.message || 'Item not found',
         };
     }
     // Step 2: Check item type and resolve accordingly
@@ -62,7 +62,7 @@ export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
                 return {
                     inputItem: item,
                     assignmentId: 0,
-                    error: `Failed to find assignments: ${assignmentError}`,
+                    error: `Failed to find assignments: ${assignmentError.message}`,
                 };
             }
             if (!assignments || assignments.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markwharton/liquidplanner",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "LiquidPlanner API client for timesheet integration",
   "type": "module",
   "main": "dist/index.js",