@markwharton/liquidplanner 2.3.0 → 2.4.1

package/README.md

@@ -27,22 +27,6 @@ if (wsResult.ok) console.log(wsResult.data); // LPWorkspace[]
 const membersResult = await client.getWorkspaceMembers();
 if (membersResult.ok) console.log(membersResult.data); // LPMember[]
 
-// Get user's assignments (for task picker)
-const assignResult = await client.getMyAssignments(memberId);
-if (assignResult.ok) console.log(assignResult.data); // LPItem[]
-
-// Get assignments with parent task/project names resolved
-const ctxResult = await client.getMyAssignmentsWithContext(memberId, {
-  includeProject: true  // optional: also fetch project names
-});
-if (ctxResult.ok) console.log(ctxResult.data); // LPAssignmentWithContext[]
-
-// Get assignments with full hierarchy path
-const hierResult = await client.getMyAssignmentsWithContext(memberId, {
-  includeHierarchy: true  // includes ancestors and hierarchyPath
-});
-if (hierResult.ok) console.log(hierResult.data); // LPAssignmentWithContext[]
-
 // Get item ancestors (hierarchy chain)
 const ancResult = await client.getItemAncestors(itemId);
 if (ancResult.ok) console.log(ancResult.data); // LPAncestor[]
@@ -60,7 +44,7 @@ await client.createTimesheetEntry({
 
 // Query existing entries for a date
 const tsResult = await client.getTimesheetEntries('2026-01-29', assignmentId);
-if (tsResult.ok) console.log(tsResult.data); // LPTimesheetEntryWithId[]
+if (tsResult.ok) console.log(tsResult.data); // LPTimesheetEntry[]
 
 // Update an existing entry (accumulate hours)
 const existing = tsResult.data![0];
@@ -85,8 +69,8 @@ if (childResult.ok) console.log(childResult.data); // LPItem[]
 const treeResult = await client.getWorkspaceTree();
 if (treeResult.ok) console.log(treeResult.data); // LPWorkspaceTree
 
-// Get a member's work with full context from the tree
-const workResult = await client.getMyWork(memberId);
+// Get a member's assignments with full context from the tree
+const workResult = await client.getAssignments(memberId);
 if (workResult.ok) {
   const { assignments, treeItemCount } = workResult.data;
   // Each assignment includes taskName, projectId, projectName, hierarchyPath, ancestors
@@ -114,25 +98,7 @@ const lateTasks = findInTree(tree, item => item.late === true);
 
 ## Result Pattern
 
-All methods return `Result<T>` objects rather than throwing exceptions. Always check `ok` before accessing `data`:
-
-```typescript
-interface Result<T> {
-  ok: boolean;
-  data?: T;       // present when ok is true
-  error?: string;  // present when ok is false
-  status?: number; // HTTP status code on error
-}
-```
-
-```typescript
-const result = await client.getMyWork(memberId);
-if (!result.ok) {
-  console.error(result.error, result.status);
-  return;
-}
-const { assignments, treeItemCount } = result.data;
-```
+All methods return `Result<T>` — see [api-core Result Pattern](../../README.md#result-pattern). Always check `ok` before accessing `data`.
 
 ## API Reference
 
@@ -145,17 +111,20 @@ const { assignments, treeItemCount } = result.data;
 | `getItems(itemIds)` | `number[]` | `Result<LPItem[]>` |
 | `getItemAncestors(itemId)` | `number` | `Result<LPAncestor[]>` |
 | `findAssignments(taskId)` | `number` | `Result<LPItem[]>` |
-| `getMyAssignments(memberId)` | `number` | `Result<LPItem[]>` |
-| `getMyAssignmentsWithContext(memberId, options?)` | `number, { includeProject?, includeHierarchy? }` | `Result<LPAssignmentWithContext[]>` |
 | `findItems(options)` | `LPFindItemsOptions` | `Result<LPItem[]>` |
 | `getChildren(parentId, options?)` | `number, { itemType? }?` | `Result<LPItem[]>` |
 | `getWorkspaceTree()` | — | `Result<LPWorkspaceTree>` |
-| `getMyWork(memberId)` | `number` | `Result<{ assignments: LPAssignmentWithContext[], treeItemCount: number }>` |
+| `getAssignments(memberId)` | `number` | `Result<{ assignments: LPAssignment[], treeItemCount: number }>` |
+| `clearCache()` | — | `void` |
+| `invalidateTimesheetCache()` | — | `void` |
 | `invalidateTreeCache()` | — | `void` |
+| `invalidateMemberCache()` | — | `void` |
+| `invalidateItemCache()` | — | `void` |
+| `invalidateCostCodeCache()` | — | `void` |
 | `getCostCodes()` | — | `Result<LPCostCode[]>` |
 | `createTimesheetEntry(entry)` | `LPTimesheetEntry` | `LPSyncResult` |
-| `getTimesheetEntries(date, itemId?)` | `string \| string[], number?` | `Result<LPTimesheetEntryWithId[]>` |
-| `updateTimesheetEntry(entryId, existing, updates)` | `number, LPTimesheetEntryWithId, Partial<LPTimesheetEntry>` | `LPSyncResult` |
+| `getTimesheetEntries(date, itemId?)` | `string \| string[], number?` | `Result<LPTimesheetEntry[]>` |
+| `updateTimesheetEntry(entryId, existing, updates)` | `number, LPTimesheetEntry, Partial<LPTimesheetEntry>` | `LPSyncResult` |
 | `upsertTimesheetEntry(entry, options?)` | `LPTimesheetEntry, LPUpsertOptions?` | `LPSyncResult` |
 
 ### Workflow: `resolveTaskToAssignment`
@@ -219,12 +188,11 @@ const client = new LPClient({
 | Workspace members | 5 min |
 | Cost codes | 5 min |
 | Items / ancestors | 5 min |
-| Assignments | 2 min |
 | Timesheet entries | 60s |
 
-Write operations (`createTimesheetEntry`, `updateTimesheetEntry`) automatically invalidate timesheet cache entries. Call `client.invalidateTreeCache()` to refresh the workspace tree, or `client.clearCache()` to clear all cached data.
+Write operations (`createTimesheetEntry`, `updateTimesheetEntry`) automatically invalidate timesheet cache entries. Use focused invalidation methods (`invalidateTreeCache`, `invalidateMemberCache`, `invalidateItemCache`, `invalidateTimesheetCache`, `invalidateCostCodeCache`) to refresh specific data, or `clearCache()` to clear everything.
 
-Failed API results (`ok: false`) are never cached — transient errors won't persist for the full TTL. See the [root README Cache System section](../../README.md#cache-system) for the full cache architecture (layered stores, PII handling, request coalescing).
+Failed API results (`ok: false`) are never cached — transient errors won't persist for the full TTL. See the [root README Cache System section](../../README.md#cache-system) for the full cache architecture (layered stores, restricted data handling, request coalescing).
 
 ### Retry
 

package/dist/client.d.ts

@@ -7,7 +7,7 @@
  * @see https://api-docs.liquidplanner.com/
  */
 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';
+import type { LPConfig, LPWorkspace, LPMember, LPItem, LPCostCode, LPSyncResult, LPTimesheetEntry, LPUpsertOptions, LPAssignment, LPAncestor, LPFindItemsOptions, LPWorkspaceTree } from './types.js';
 /**
  * LiquidPlanner API Client
  *
@@ -39,11 +39,7 @@ export declare class LPClient {
     private readonly cacheTtl;
     private readonly retryConfig?;
     constructor(config: LPConfig);
-    /**
-     * Route through cache if enabled, otherwise call factory directly.
-     * Failed Results (ok === false) are never cached — transient errors
-     * shouldn't persist for the full TTL.
-     */
+    /** Route through cache if enabled, skipping failed Results. */
     private cached;
     /**
      * Clear all cached API responses.
@@ -52,21 +48,24 @@ export declare class LPClient {
     clearCache(): void;
     /**
      * Invalidate cached timesheet entries only.
-     * Use when an external event (e.g., SignalR broadcast) indicates timesheet
-     * data changed but the write didn't go through this client instance.
      */
     invalidateTimesheetCache(): void;
-    /**
-     * Invalidate cached assignments only.
-     * Use when an external event indicates assignment data changed
-     * (e.g., after logging time which updates loggedHoursRollup).
-     */
-    invalidateAssignmentsCache(): void;
     /**
      * Invalidate cached workspace tree snapshot only.
-     * Use when the workspace structure changes (items created, moved, or deleted).
      */
     invalidateTreeCache(): void;
+    /**
+     * Invalidate cached workspace members only.
+     */
+    invalidateMemberCache(): void;
+    /**
+     * Invalidate cached items and ancestors only.
+     */
+    invalidateItemCache(): void;
+    /**
+     * Invalidate cached cost codes only.
+     */
+    invalidateCostCodeCache(): void;
     /**
      * Make an authenticated request to the LP API
      *
@@ -88,7 +87,7 @@ export declare class LPClient {
      */
     private fetchAndParseMutation;
     /**
-     * Validate the API token by listing workspaces
+     * Validate the API token
      */
     validateToken(): Promise<Result<void>>;
     /**
@@ -96,7 +95,7 @@ export declare class LPClient {
      */
     getWorkspaces(): Promise<Result<LPWorkspace[]>>;
     /**
-     * Get all members in the workspace (with pagination)
+     * Get all members in the workspace
      */
     getWorkspaceMembers(): Promise<Result<LPMember[]>>;
     /**
@@ -122,37 +121,9 @@ export declare class LPClient {
      */
     getItemAncestors(itemId: number): Promise<Result<LPAncestor[]>>;
     /**
-     * Find all assignments under a task (with pagination)
+     * Find all assignments under a task
      */
     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.
-     * The full unfiltered dataset is cached once; all memberId queries share the same cache entry.
-     */
-    getMyAssignments(memberId: number): Promise<Result<LPItem[]>>;
-    /**
-     * Get assignments for a member with parent task names resolved
-     *
-     * This is a convenience method that fetches assignments and enriches
-     * them with parent task names using batch fetching.
-     *
-     * Request counts:
-     * - Default: 2 requests (assignments + tasks)
-     * - includeProject: 3 requests (assignments + tasks + projects)
-     * - includeHierarchy: 1 + N requests (assignments + N ancestors calls)
-     *
-     * @param memberId - The member ID to get assignments for
-     * @param options - Options for including additional context
-     * @param options.includeProject - If true, also fetch grandparent project names
-     * @param options.includeHierarchy - If true, fetch full ancestry and build hierarchy path
-     */
-    getMyAssignmentsWithContext(memberId: number, options?: {
-        includeProject?: boolean;
-        includeHierarchy?: boolean;
-    }): Promise<Result<LPAssignmentWithContext[]>>;
     /**
      * Query items with LP API filters
      *
@@ -193,20 +164,19 @@ export declare class LPClient {
     /**
      * 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.
+     * eliminating N+1 ancestor request patterns.
      *
      * API calls: 0 (if tree cached) or 1-3 (cold load)
      *
-     * @param memberId - The member ID to get work for
+     * @param memberId - The member ID to get assignments for
      */
-    getMyWork(memberId: number): Promise<Result<{
-        assignments: LPAssignmentWithContext[];
+    getAssignments(memberId: number): Promise<Result<{
+        assignments: LPAssignment[];
         treeItemCount: number;
     }>>;
     /**
-     * Get all cost codes in the workspace (with pagination)
+     * Get all cost codes in the workspace
      */
     getCostCodes(): Promise<Result<LPCostCode[]>>;
     /**
@@ -230,7 +200,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<Result<LPTimesheetEntryWithId[]>>;
+    getTimesheetEntries(date: string | string[], itemId?: number): Promise<Result<LPTimesheetEntry[]>>;
     /**
      * Update an existing timesheet entry
      *
@@ -250,7 +220,7 @@ export declare class LPClient {
      * @param existingEntry - The existing entry (needed because PUT requires all fields)
      * @param updates - Fields to update (merged with existing)
      */
-    updateTimesheetEntry(entryId: number, existingEntry: LPTimesheetEntryWithId, updates: Partial<LPTimesheetEntry>): Promise<LPSyncResult>;
+    updateTimesheetEntry(entryId: number, existingEntry: LPTimesheetEntry, updates: Partial<LPTimesheetEntry>): Promise<LPSyncResult>;
     /**
      * Create or update a timesheet entry (upsert)
      *

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, ok, okVoid, err, resolveRetryConfig } from '@markwharton/api-core';
+import { getErrorMessage, fetchWithRetry, ok, okVoid, err, resolveRetryConfig, cachedResult, fetchAndParseResponse, resolveClientCache } from '@markwharton/api-core';
 /** Transform raw API item to LPItem, preserving scheduling and effort fields */
 function transformItem(raw) {
     const item = {
@@ -114,32 +114,20 @@ export class LPClient {
         this.baseUrl = config.baseUrl ?? LP_API_BASE;
         this.onRequest = config.onRequest;
         // Initialize cache if configured
-        if (config.cache || config.cacheInstance) {
-            this.cache = config.cacheInstance ?? new TTLCache();
-        }
+        this.cache = resolveClientCache(config);
         this.cacheTtl = {
             membersTtl: config.cache?.membersTtl ?? 300000,
             costCodesTtl: config.cache?.costCodesTtl ?? 300000,
             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
         this.retryConfig = resolveRetryConfig(config.retry);
     }
-    /**
-     * Route through cache if enabled, otherwise call factory directly.
-     * Failed Results (ok === false) are never cached — transient errors
-     * shouldn't persist for the full TTL.
-     */
-    async cached(key, ttlMs, factory, options) {
-        if (!this.cache)
-            return factory();
-        return this.cache.get(key, ttlMs, factory, {
-            ...options,
-            shouldCache: (data) => data.ok !== false,
-        });
+    /** Route through cache if enabled, skipping failed Results. */
+    cached(key, ttlMs, factory, options) {
+        return cachedResult(this.cache, key, ttlMs, factory, options);
     }
     /**
      * Clear all cached API responses.
@@ -150,27 +138,35 @@ export class LPClient {
     }
     /**
      * Invalidate cached timesheet entries only.
-     * Use when an external event (e.g., SignalR broadcast) indicates timesheet
-     * data changed but the write didn't go through this client instance.
      */
     invalidateTimesheetCache() {
         this.cache?.invalidate('timesheet:');
     }
-    /**
-     * Invalidate cached assignments only.
-     * Use when an external event indicates assignment data changed
-     * (e.g., after logging time which updates loggedHoursRollup).
-     */
-    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');
     }
+    /**
+     * Invalidate cached workspace members only.
+     */
+    invalidateMemberCache() {
+        this.cache?.invalidate('members');
+    }
+    /**
+     * Invalidate cached items and ancestors only.
+     */
+    invalidateItemCache() {
+        this.cache?.invalidate('item:');
+        this.cache?.invalidate('ancestors:');
+    }
+    /**
+     * Invalidate cached cost codes only.
+     */
+    invalidateCostCodeCache() {
+        this.cache?.invalidate('costcodes');
+    }
     /**
      * Make an authenticated request to the LP API
      *
@@ -209,19 +205,8 @@ export class LPClient {
     /**
      * Fetch a URL and parse the response, with standardized error handling.
      */
-    async fetchAndParse(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 ? { isDuplicate } : {}) };
-            }
-            return ok(await parse(response));
-        }
-        catch (error) {
-            return err(getErrorMessage(error), 0);
-        }
+    fetchAndParse(url, parse, fetchOptions) {
+        return fetchAndParseResponse(() => this.fetch(url, fetchOptions), parse, parseLPErrorResponse);
     }
     /**
      * Fetch and parse with isDuplicate support for mutation methods.
@@ -245,7 +230,7 @@ export class LPClient {
     // Workspace & Validation
     // ============================================================================
     /**
-     * Validate the API token by listing workspaces
+     * Validate the API token
      */
     async validateToken() {
         const url = `${this.baseUrl}/workspaces/v1`;
@@ -277,7 +262,7 @@ export class LPClient {
     // Members
     // ============================================================================
     /**
-     * Get all members in the workspace (with pagination)
+     * Get all members in the workspace
      */
     async getWorkspaceMembers() {
         return this.cached('members', this.cacheTtl.membersTtl, async () => {
@@ -360,7 +345,7 @@ export class LPClient {
         });
     }
     /**
-     * Find all assignments under a task (with pagination)
+     * Find all assignments under a task
      */
     async findAssignments(taskId) {
         // parentId[is]="{taskId}"&itemType[is]="assignments" (LP API uses lowercase plural)
@@ -371,145 +356,6 @@ export class LPClient {
             transform: (data) => data.map(transformItem),
         });
     }
-    /**
-     * 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.
-     * The full unfiltered dataset is cached once; all memberId queries share the same cache entry.
-     */
-    async getMyAssignments(memberId) {
-        const result = await this.cached('assignments', this.cacheTtl.assignmentsTtl, async () => {
-            const baseUrl = this.workspaceUrl(`items/v1?${filterIs('itemType', 'assignments')}`);
-            return paginatedFetch({
-                fetchFn: (url) => this.fetch(url),
-                baseUrl,
-                transform: (data) => data.map(transformItem),
-            });
-        });
-        if (!result.ok)
-            return result;
-        return ok(result.data.filter(item => item.userId === memberId));
-    }
-    /**
-     * Get assignments for a member with parent task names resolved
-     *
-     * This is a convenience method that fetches assignments and enriches
-     * them with parent task names using batch fetching.
-     *
-     * Request counts:
-     * - Default: 2 requests (assignments + tasks)
-     * - includeProject: 3 requests (assignments + tasks + projects)
-     * - includeHierarchy: 1 + N requests (assignments + N ancestors calls)
-     *
-     * @param memberId - The member ID to get assignments for
-     * @param options - Options for including additional context
-     * @param options.includeProject - If true, also fetch grandparent project names
-     * @param options.includeHierarchy - If true, fetch full ancestry and build hierarchy path
-     */
-    async getMyAssignmentsWithContext(memberId, options) {
-        // 1. Get raw assignments
-        const assignResult = await this.getMyAssignments(memberId);
-        if (!assignResult.ok)
-            return assignResult;
-        const assignments = assignResult.data;
-        if (assignments.length === 0)
-            return ok([]);
-        // 2. Handle based on options
-        let taskMap = new Map();
-        let projectMap = new Map();
-        let ancestorMap = new Map();
-        if (options?.includeHierarchy) {
-            // Optimized path: fetch ancestors for assignments (includes task info)
-            // This avoids the separate task batch fetch since task is first ancestor
-            // Deduplicate by parentId - only one ancestors call per unique parent task
-            const assignmentsByParent = new Map();
-            for (const a of assignments) {
-                if (a.parentId && !assignmentsByParent.has(a.parentId)) {
-                    assignmentsByParent.set(a.parentId, a);
-                }
-            }
-            const parentEntries = [...assignmentsByParent.entries()];
-            const ancestorResults = await batchMap(parentEntries, 5, async ([parentId, assignment]) => {
-                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 firstError.error;
-            }
-            for (const { parentId, ancestors } of ancestorResults) {
-                ancestorMap.set(parentId, ancestors);
-            }
-        }
-        else {
-            // Original path: batch fetch tasks first
-            const taskIds = [...new Set(assignments.map(a => a.parentId).filter((id) => id !== undefined))];
-            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 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 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.projectName = null;
-                    }
-                }
-                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;
-                }
-            }
-            return result;
-        }));
-    }
     // ============================================================================
     // Item Queries (Rich Filtering)
     // ============================================================================
@@ -622,15 +468,14 @@ export class LPClient {
     /**
      * 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.
+     * eliminating N+1 ancestor request patterns.
      *
      * API calls: 0 (if tree cached) or 1-3 (cold load)
      *
-     * @param memberId - The member ID to get work for
+     * @param memberId - The member ID to get assignments for
      */
-    async getMyWork(memberId) {
+    async getAssignments(memberId) {
         const treeResult = await this.getWorkspaceTree();
         if (!treeResult.ok)
             return err(treeResult.error, treeResult.status);
@@ -664,7 +509,7 @@ export class LPClient {
     // Cost Codes
     // ============================================================================
     /**
-     * Get all cost codes in the workspace (with pagination)
+     * Get all cost codes in the workspace
      */
     async getCostCodes() {
         return this.cached('costcodes', this.cacheTtl.costCodesTtl, async () => {

package/dist/index.d.ts

@@ -30,7 +30,7 @@
  */
 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, LPUpsertOptions, LPAssignmentWithContext, LPFindItemsOptions, LPTreeNode, LPWorkspaceTree, } from './types.js';
+export type { LPConfig, LPCacheConfig, LPRetryConfig, LPItemType, HierarchyItem, LPItem, LPAncestor, LPWorkspace, LPMember, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTaskResolution, LPUpsertOptions, LPAssignment, LPFindItemsOptions, LPTreeNode, LPWorkspaceTree, } from './types.js';
 export type { AccessTier } from './types.js';
 export { METHOD_TIERS } from './types.js';
 export { ok, err, getErrorMessage, TTLCache, MemoryCacheStore, LayeredCache } from '@markwharton/api-core';

package/dist/types.d.ts

@@ -183,8 +183,6 @@ export interface LPCacheConfig {
     costCodesTtl?: number;
     /** TTL for timesheet entries (default: 60000 = 60s) */
     timesheetTtl?: number;
-    /** TTL for user assignments (default: 120000 = 2 min) */
-    assignmentsTtl?: number;
     /** TTL for items and ancestors (default: 300000 = 5 min) */
     itemsTtl?: number;
     /** TTL for workspace tree snapshot (default: 600000 = 10 min) */
@@ -219,9 +217,11 @@ export interface LPSyncResult extends Result<number> {
     isDuplicate?: boolean;
 }
 /**
- * Input for a timesheet entry to sync
+ * A timesheet entry (input for create/update, or response from queries)
  */
 export interface LPTimesheetEntry {
+    /** Unique identifier (present in API responses) */
+    id?: number;
     /** Date in YYYY-MM-DD format */
     date: string;
     /** Item ID (should be an Assignment ID) */
@@ -232,14 +232,7 @@ export interface LPTimesheetEntry {
     costCodeId?: number;
     /** Optional note/description */
     note?: string;
-}
-/**
- * A timesheet entry returned from LP API queries (includes ID)
- */
-export interface LPTimesheetEntryWithId extends LPTimesheetEntry {
-    /** Unique identifier for the entry */
-    id: number;
-    /** User ID who logged the time */
+    /** User ID who logged the time (present in API responses) */
     userId?: number;
 }
 /**
@@ -259,7 +252,7 @@ export interface LPUpsertOptions {
  * Extends LPItem with additional fields for the parent task name,
  * grandparent project name, and cost code name.
  */
-export interface LPAssignmentWithContext extends LPItem {
+export interface LPAssignment extends LPItem {
     /** Parent task name (null if not found) */
     taskName?: string | null;
     /** Grandparent project ID (undefined if not requested/found) */

package/dist/types.js

@@ -17,12 +17,10 @@ export const METHOD_TIERS = {
     getItems: 'standard',
     getItemAncestors: 'standard',
     findAssignments: 'standard',
-    getMyAssignments: 'standard',
-    getMyAssignmentsWithContext: 'standard',
     findItems: 'standard',
     getChildren: 'standard',
     getWorkspaceTree: 'standard',
-    getMyWork: 'standard',
+    getAssignments: 'standard',
     getCostCodes: 'standard',
     createTimesheetEntry: 'standard',
     getTimesheetEntries: 'standard',

package/dist/utils.js

@@ -6,36 +6,40 @@ import { getErrorMessage, err } from '@markwharton/api-core';
 // ============================================================================
 // LP API Filter Builders
 // ============================================================================
+/** Encode a value for embedding in a pre-encoded LP filter string: %22<encoded-value>%22 */
+function encodeFilterValue(value) {
+    return `%22${String(value).replace(/\+/g, '%2B')}%22`;
+}
 /**
  * Build a URL-encoded filter for LP API: field[is]="value"
  */
 export function filterIs(field, value) {
-    return `${field}%5Bis%5D=%22${value}%22`;
+    return `${field}%5Bis%5D=${encodeFilterValue(value)}`;
 }
 /**
  * Build a URL-encoded filter for LP API: field[is_not]="value"
  */
 export function filterIsNot(field, value) {
-    return `${field}%5Bis_not%5D=%22${value}%22`;
+    return `${field}%5Bis_not%5D=${encodeFilterValue(value)}`;
 }
 /**
  * Build a URL-encoded filter for LP API: field[in]=["value1","value2"]
  */
 export function filterIn(field, values) {
-    const encoded = values.map(v => `%22${v}%22`).join(',');
+    const encoded = values.map(v => encodeFilterValue(v)).join(',');
     return `${field}%5Bin%5D=%5B${encoded}%5D`;
 }
 /**
  * Build a URL-encoded filter for LP API: field[gt]="value"
  */
 export function filterGt(field, value) {
-    return `${field}%5Bgt%5D=%22${value}%22`;
+    return `${field}%5Bgt%5D=${encodeFilterValue(value)}`;
 }
 /**
  * Build a URL-encoded filter for LP API: field[lt]="value"
  */
 export function filterLt(field, value) {
-    return `${field}%5Blt%5D=%22${value}%22`;
+    return `${field}%5Blt%5D=${encodeFilterValue(value)}`;
 }
 /** Normalize YYYY-MM-DD to ISO offset string using local timezone (LP API requires ISO for date filters) */
 function toISODateValue(value) {
@@ -54,7 +58,7 @@ function toISODateValue(value) {
  * Accepts YYYY-MM-DD or full ISO strings.
  */
 export function filterAfter(field, value) {
-    return `${field}%5Bafter%5D=%22${toISODateValue(value)}%22`;
+    return `${field}%5Bafter%5D=${encodeFilterValue(toISODateValue(value))}`;
 }
 /**
  * Build a URL-encoded filter for LP API: field[before]="value"
@@ -62,7 +66,7 @@ export function filterAfter(field, value) {
  * Accepts YYYY-MM-DD or full ISO strings.
  */
 export function filterBefore(field, value) {
-    return `${field}%5Bbefore%5D=%22${toISODateValue(value)}%22`;
+    return `${field}%5Bbefore%5D=${encodeFilterValue(toISODateValue(value))}`;
 }
 /**
  * Join multiple filter expressions with &

package/package.json

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