@markwharton/liquidplanner 2.2.0 → 2.4.0

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[]
@@ -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
@@ -126,7 +110,7 @@ interface Result<T> {
 ```
 
 ```typescript
-const result = await client.getMyWork(memberId);
+const result = await client.getAssignments(memberId);
 if (!result.ok) {
   console.error(result.error, result.status);
   return;
@@ -145,12 +129,10 @@ 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 }>` |
 | `invalidateTreeCache()` | — | `void` |
 | `getCostCodes()` | — | `Result<LPCostCode[]>` |
 | `createTimesheetEntry(entry)` | `LPTimesheetEntry` | `LPSyncResult` |
@@ -219,12 +201,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.
 
-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, LPTimesheetEntryWithId, LPUpsertOptions, LPAssignment, LPAncestor, LPFindItemsOptions, LPWorkspaceTree } from './types.js';
 /**
  * LiquidPlanner API Client
  *
@@ -125,34 +125,6 @@ export declare class LPClient {
      * Find all assignments under a task (with pagination)
      */
     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,16 +165,15 @@ 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;
     }>>;
     /**

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 { TTLCache, getErrorMessage, fetchWithRetry, ok, okVoid, err, resolveRetryConfig } from '@markwharton/api-core';
 /** Transform raw API item to LPItem, preserving scheduling and effort fields */
 function transformItem(raw) {
     const item = {
@@ -121,7 +121,6 @@ export class LPClient {
             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,
         };
@@ -371,145 +370,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 +482,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);

package/dist/index.d.ts

@@ -30,7 +30,9 @@
  */
 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, LPTimesheetEntryWithId, 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';
 export type { Result, RetryConfig, OnRequestCallback, ClientConfig, Cache, CacheStore, CacheGetOptions } from '@markwharton/api-core';
 export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIsNot, filterIn, filterGt, filterLt, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';

package/dist/index.js

@@ -32,6 +32,7 @@
 export { LPClient } from './client.js';
 // Workflows
 export { resolveTaskToAssignment } from './workflows.js';
+export { METHOD_TIERS } from './types.js';
 // Re-exported from @markwharton/api-core
 export { ok, err, getErrorMessage, TTLCache, MemoryCacheStore, LayeredCache } from '@markwharton/api-core';
 // Utilities

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) */
@@ -206,6 +204,8 @@ export interface LPConfig extends ClientConfig {
     apiToken: string;
     /** Enable caching with optional TTL overrides. Omit to disable caching. */
     cache?: LPCacheConfig;
+    /** Whether to persist restricted-tier data in persistent cache stores (default: true). Set false to keep restricted data in memory only. */
+    persistRestricted?: boolean;
 }
 /**
  * Result of a timesheet sync operation
@@ -257,7 +257,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) */
@@ -336,3 +336,12 @@ export interface LPWorkspaceTree {
     /** Total number of items in the tree */
     itemCount: number;
 }
+/** Access tier for method-level authorization */
+export type AccessTier = 'standard' | 'restricted';
+/**
+ * Access tier for each data method.
+ *
+ * All LP methods are standard tier — LP data is workspace-scoped, not employee-scoped.
+ * Utility methods (validate, clear, invalidate) are not included.
+ */
+export declare const METHOD_TIERS: Record<string, AccessTier>;

package/dist/types.js

@@ -4,4 +4,26 @@
  * These types define the data structures used when interacting with
  * the LiquidPlanner API.
  */
-export {};
+/**
+ * Access tier for each data method.
+ *
+ * All LP methods are standard tier — LP data is workspace-scoped, not employee-scoped.
+ * Utility methods (validate, clear, invalidate) are not included.
+ */
+export const METHOD_TIERS = {
+    getWorkspaces: 'standard',
+    getWorkspaceMembers: 'standard',
+    getItem: 'standard',
+    getItems: 'standard',
+    getItemAncestors: 'standard',
+    findAssignments: 'standard',
+    findItems: 'standard',
+    getChildren: 'standard',
+    getWorkspaceTree: 'standard',
+    getAssignments: 'standard',
+    getCostCodes: 'standard',
+    createTimesheetEntry: 'standard',
+    getTimesheetEntries: 'standard',
+    updateTimesheetEntry: 'standard',
+    upsertTimesheetEntry: 'standard',
+};

package/package.json

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