@markwharton/liquidplanner 3.0.0 → 3.2.0

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, LPUpsertOptions, LPAssignment, LPAncestor, LPFindItemsOptions, LPWorkspaceTree } from './types.js';
+import type { LPConfig, LPWorkspace, LPMember, LPItem, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTimesheetOptions, LPUpsertOptions, LPAncestor, LPFindItemsOptions, LPWorkspaceTree, LPAssignmentsResult } from './types.js';
 /**
  * LiquidPlanner API Client
  *
@@ -166,19 +166,19 @@ export declare class LPClient {
      */
     getWorkspaceTree(): Promise<Result<LPWorkspaceTree>>;
     /**
-     * Get a member's active work with full context from the workspace tree
+     * Get assignments with full context from the workspace tree
+     *
+     * Returns a normalized result with shared lookup tables for ancestor items
+     * and custom field values, reducing payload size for large workspaces.
      *
      * Uses the workspace tree snapshot (cached) to resolve hierarchy locally,
      * eliminating N+1 ancestor request patterns.
      *
      * API calls: 0 (if tree cached) or 1-3 (cold load)
      *
-     * @param memberId - The member ID to get assignments for
+     * @param memberId - Filter to a specific member's assignments. When omitted, returns all members' assignments.
      */
-    getAssignments(memberId: number): Promise<Result<{
-        assignments: LPAssignment[];
-        treeItemCount: number;
-    }>>;
+    getAssignments(memberId?: number): Promise<Result<LPAssignmentsResult>>;
     /**
      * Get all cost codes in the workspace
      */
@@ -202,9 +202,9 @@ export declare class LPClient {
      * @see https://api-docs.liquidplanner.com/docs/task-status-1
      *
      * @param date - Date(s) in YYYY-MM-DD format (string or array)
-     * @param itemId - Optional item ID to filter by
+     * @param options - Optional filters (itemId, memberId)
      */
-    getTimesheetEntries(date: string | string[], itemId?: number): Promise<Result<LPTimesheetEntry[]>>;
+    getTimesheetEntries(date: string | string[], options?: LPTimesheetOptions): Promise<Result<LPTimesheetEntry[]>>;
     /**
      * Update an existing timesheet entry
      *

package/dist/client.js

@@ -473,31 +473,62 @@ export class LPClient {
         });
     }
     /**
-     * Get a member's active work with full context from the workspace tree
+     * Get assignments with full context from the workspace tree
+     *
+     * Returns a normalized result with shared lookup tables for ancestor items
+     * and custom field values, reducing payload size for large workspaces.
      *
      * Uses the workspace tree snapshot (cached) to resolve hierarchy locally,
      * eliminating N+1 ancestor request patterns.
      *
      * API calls: 0 (if tree cached) or 1-3 (cold load)
      *
-     * @param memberId - The member ID to get assignments for
+     * @param memberId - Filter to a specific member's assignments. When omitted, returns all members' assignments.
      */
     async getAssignments(memberId) {
         const treeResult = await this.getWorkspaceTree();
         if (!treeResult.ok)
             return err(treeResult.error, treeResult.status);
         const tree = treeResult.data;
-        const assignments = [];
+        const items = {};
+        const cfvMap = new Map();
+        const cfvArray = [];
+        const memberMap = new Map();
         for (const node of tree.byId.values()) {
-            if (node.itemType !== 'assignments' || node.userId !== memberId)
+            if (node.itemType !== 'assignments')
+                continue;
+            if (memberId !== undefined && node.userId !== memberId)
                 continue;
             const ancestors = getTreeAncestors(tree, node.id);
             const taskAncestor = ancestors.find(a => a.itemType === 'tasks');
             const hierarchyAncestors = ancestors.filter(a => a.itemType === 'projects' || a.itemType === 'folders');
-            const { children: _, ...itemFields } = node;
-            const result = { ...itemFields };
+            // Collect ancestor items into shared lookup
+            for (const anc of ancestors) {
+                if (!items[anc.id]) {
+                    const treeNode = tree.byId.get(anc.id);
+                    items[anc.id] = {
+                        id: anc.id,
+                        name: anc.name,
+                        itemType: anc.itemType,
+                        parentId: treeNode?.parentId,
+                    };
+                }
+            }
+            // Dedup customFieldValues
+            const { children: _, customFieldValues, ...itemFields } = node;
+            let customFieldValuesIndex;
+            if (customFieldValues) {
+                const key = JSON.stringify(customFieldValues);
+                let idx = cfvMap.get(key);
+                if (idx === undefined) {
+                    idx = cfvArray.length;
+                    cfvArray.push(customFieldValues);
+                    cfvMap.set(key, idx);
+                }
+                customFieldValuesIndex = idx;
+            }
+            const result = { ...itemFields, customFieldValuesIndex };
             result.taskName = taskAncestor?.name ?? null;
-            result.ancestors = ancestors;
             if (hierarchyAncestors.length > 0) {
                 result.projectId = hierarchyAncestors[0].id;
                 result.projectName = hierarchyAncestors[0].name;
@@ -508,9 +539,19 @@ export class LPClient {
             else {
                 result.projectName = null;
             }
-            assignments.push(result);
+            // Group by member
+            const uid = node.userId ?? 0;
+            let memberAssignments = memberMap.get(uid);
+            if (!memberAssignments) {
+                memberAssignments = [];
+                memberMap.set(uid, memberAssignments);
+            }
+            memberAssignments.push(result);
         }
-        return ok({ assignments, treeItemCount: tree.itemCount });
+        const members = [...memberMap.entries()]
+            .sort(([a], [b]) => a - b)
+            .map(([mid, assignments]) => ({ memberId: mid, assignments }));
+        return ok({ members, items, customFieldValues: cfvArray, treeItemCount: tree.itemCount });
     }
     // ============================================================================
     // Cost Codes
@@ -576,12 +617,18 @@ export class LPClient {
      * @see https://api-docs.liquidplanner.com/docs/task-status-1
      *
      * @param date - Date(s) in YYYY-MM-DD format (string or array)
-     * @param itemId - Optional item ID to filter by
+     * @param options - Optional filters (itemId, memberId)
      */
-    async getTimesheetEntries(date, itemId) {
+    async getTimesheetEntries(date, options) {
         const dates = Array.isArray(date) ? date : [date];
         const sortedKey = [...dates].sort().join(',');
-        const cacheKey = itemId ? `timesheet:${sortedKey}:${itemId}` : `timesheet:${sortedKey}`;
+        const { itemId, memberId } = options || {};
+        // Build cache key from all filter dimensions
+        let cacheKey = `timesheet:${sortedKey}`;
+        if (itemId)
+            cacheKey += `:item=${itemId}`;
+        if (memberId)
+            cacheKey += `:member=${memberId}`;
         return this.cached(cacheKey, this.cacheTtl.timesheetTtl, async () => {
             // Build query with date[in] filter (supports multiple dates)
             let baseUrl = this.workspaceUrl(`logged-time-entries/v1?${filterIn('date', dates)}`);
@@ -589,6 +636,10 @@ export class LPClient {
             if (itemId) {
                 baseUrl += `&${filterIs('itemId', itemId)}`;
             }
+            // Optional filter by memberId (server-side user filtering)
+            if (memberId) {
+                baseUrl += `&${filterIs('userId', memberId)}`;
+            }
             return paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
@@ -679,7 +730,7 @@ export class LPClient {
     async upsertTimesheetEntry(entry, options = {}) {
         const { accumulate = true } = options;
         // Fetch existing entries for this date/item first
-        const fetchResult = await this.getTimesheetEntries(entry.date, entry.itemId);
+        const fetchResult = await this.getTimesheetEntries(entry.date, { itemId: entry.itemId });
         if (!fetchResult.ok) {
             return { ok: false, error: fetchResult.error, status: fetchResult.status };
         }

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, LPUserType, LPHierarchyItem, LPItem, LPAncestor, LPWorkspace, LPMember, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTaskResolution, LPUpsertOptions, LPAssignment, LPFindItemsOptions, LPTreeNode, LPWorkspaceTree, } from './types.js';
+export type { LPConfig, LPCacheConfig, LPRetryConfig, LPItemType, LPUserType, LPHierarchyItem, LPItem, LPAncestor, LPWorkspace, LPMember, LPCostCode, LPSyncResult, LPTimesheetEntry, LPTaskResolution, LPTimesheetOptions, LPUpsertOptions, LPAssignment, LPItemRef, LPNormalizedAssignment, LPMemberAssignments, LPAssignmentsResult, LPFindItemsOptions, LPTreeNode, LPWorkspaceTree, } from './types.js';
 export type { AccessTier } from './types.js';
 export { METHOD_TIERS, ENTITIES } from './types.js';
 export { ok, err, getErrorMessage, normalizeEnum, TTLCache, MemoryCacheStore, LayeredCache } from '@markwharton/api-core';

package/dist/types.d.ts

@@ -245,6 +245,15 @@ export interface LPTimesheetEntry {
     /** User ID who logged the time (present in API responses) */
     userId?: number;
 }
+/**
+ * Options for querying timesheet entries
+ */
+export interface LPTimesheetOptions {
+    /** Filter by assignment/item ID (itemId[is]) */
+    itemId?: number;
+    /** Filter by member ID (userId[is]) — server-side user filtering */
+    memberId?: number;
+}
 /**
  * Options for upsert timesheet entry operation
  */
@@ -274,6 +283,43 @@ export interface LPAssignment extends LPItem {
     /** Formatted hierarchy path like "Project A › Subfolder B" (undefined if not requested) */
     hierarchyPath?: string;
 }
+/**
+ * Item reference in the shared items lookup.
+ * Extends LPAncestor with parentId for ancestor chain reconstruction.
+ */
+export interface LPItemRef extends LPAncestor {
+    parentId?: number;
+}
+/**
+ * Assignment in the normalized result.
+ * Ancestors are reconstructable from the items lookup via parentId chain.
+ * Custom field values are referenced by index into the shared customFieldValues array.
+ */
+export type LPNormalizedAssignment = Omit<LPAssignment, 'ancestors' | 'customFieldValues'> & {
+    /** Index into the top-level customFieldValues array. Undefined when no custom field values. */
+    customFieldValuesIndex?: number;
+};
+/**
+ * One member's assignments in the normalized result
+ */
+export interface LPMemberAssignments {
+    memberId: number;
+    assignments: LPNormalizedAssignment[];
+}
+/**
+ * Normalized assignments result with shared lookup tables.
+ * Deduplicates ancestor items and custom field values to reduce payload size.
+ */
+export interface LPAssignmentsResult {
+    /** Assignments grouped by member. One entry when memberId specified, all members when omitted. */
+    members: LPMemberAssignments[];
+    /** Shared items lookup — walk parentId chains to reconstruct ancestor paths */
+    items: Record<number, LPItemRef>;
+    /** Deduplicated custom field value sets — indexed by assignment's customFieldValuesIndex */
+    customFieldValues: Record<string, unknown>[];
+    /** Total items in the workspace tree snapshot */
+    treeItemCount: number;
+}
 /**
  * Options for querying items with LP API filters
  *

package/package.json

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