@markwharton/liquidplanner 3.1.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, LPTimesheetOptions, 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
      */

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

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, LPTimesheetOptions, 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

@@ -283,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.1.0",
+  "version": "3.2.0",
   "description": "LiquidPlanner API client for timesheet integration",
   "type": "module",
   "main": "dist/index.js",