@markwharton/liquidplanner 2.7.2 → 3.1.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, LPAssignment, LPAncestor, LPFindItemsOptions, LPWorkspaceTree } from './types.js';
 /**
  * LiquidPlanner API Client
  *
@@ -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

@@ -6,7 +6,7 @@
  *
  * @see https://api-docs.liquidplanner.com/
  */
-import { buildAuthHeader, hoursToMinutes, normalizeItemType, filterIs, filterIsNot, filterIn, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
+import { buildAuthHeader, hoursToMinutes, filterIs, filterIsNot, filterIn, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
 import { buildTree, getTreeAncestors } from './tree.js';
 import { parseLPErrorResponse } from './errors.js';
 import { LP_API_BASE } from './constants.js';
@@ -16,7 +16,7 @@ function transformItem(raw) {
     const item = {
         id: raw.id,
         name: raw.name || null,
-        itemType: normalizeItemType(raw.itemType),
+        itemType: raw.itemType,
         parentId: raw.parentId,
         costCodeId: raw.costCodeId,
         userId: raw.userId,
@@ -346,7 +346,7 @@ export class LPClient {
                 return rawData.map((a) => ({
                     id: a.id,
                     name: a.name || null,
-                    itemType: normalizeItemType(a.itemType),
+                    itemType: a.itemType,
                 })).reverse(); // LP API returns child→root, normalize to root→child
             }, { description: `Get ancestors for item ${itemId}` });
         });
@@ -489,11 +489,11 @@ export class LPClient {
         const tree = treeResult.data;
         const assignments = [];
         for (const node of tree.byId.values()) {
-            if (node.itemType !== 'Assignment' || node.userId !== memberId)
+            if (node.itemType !== 'assignments' || node.userId !== memberId)
                 continue;
             const ancestors = getTreeAncestors(tree, node.id);
-            const taskAncestor = ancestors.find(a => a.itemType === 'Task');
-            const hierarchyAncestors = ancestors.filter(a => a.itemType === 'Project' || a.itemType === 'Folder');
+            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 };
             result.taskName = taskAncestor?.name ?? null;
@@ -576,12 +576,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 +595,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 +689,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,12 +30,12 @@
  */
 export { LPClient } from './client.js';
 export { resolveTaskToAssignment } from './workflows.js';
-export type { LPConfig, LPCacheConfig, LPRetryConfig, LPItemType, 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, 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';
 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';
+export { hoursToMinutes, buildAuthHeader, filterIs, filterIsNot, filterIn, filterGt, filterLt, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
 export type { PaginateOptions } from './utils.js';
 export { buildTree, getTreeAncestors, getTreeHierarchyPath, findInTree, } from './tree.js';
 export { LP_API_BASE } from './constants.js';

package/dist/index.js

@@ -36,7 +36,7 @@ export { METHOD_TIERS, ENTITIES } from './types.js';
 // Re-exported from @markwharton/api-core
 export { ok, err, getErrorMessage, normalizeEnum, TTLCache, MemoryCacheStore, LayeredCache } from '@markwharton/api-core';
 // Utilities
-export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIsNot, filterIn, filterGt, filterLt, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
+export { hoursToMinutes, buildAuthHeader, filterIs, filterIsNot, filterIn, filterGt, filterLt, filterAfter, filterBefore, joinFilters, paginatedFetch, } from './utils.js';
 // Tree utilities
 export { buildTree, getTreeAncestors, getTreeHierarchyPath, findInTree, } from './tree.js';
 // Constants

package/dist/tree.d.ts

@@ -22,8 +22,8 @@ export declare function getTreeAncestors(tree: LPWorkspaceTree, itemId: number):
 /**
  * Build a formatted hierarchy path for an item
  *
- * Returns a string like "Project A › Subfolder B" from Project and Folder ancestors.
- * Excludes system containers (Package, WorkspaceRoot) and Tasks.
+ * Returns a string like "Project A › Subfolder B" from projects and folders ancestors.
+ * Excludes system containers (packages, workspaceRoots) and tasks.
  */
 export declare function getTreeHierarchyPath(tree: LPWorkspaceTree, itemId: number): string;
 /**

package/dist/tree.js

@@ -62,12 +62,12 @@ export function getTreeAncestors(tree, itemId) {
 /**
  * Build a formatted hierarchy path for an item
  *
- * Returns a string like "Project A › Subfolder B" from Project and Folder ancestors.
- * Excludes system containers (Package, WorkspaceRoot) and Tasks.
+ * Returns a string like "Project A › Subfolder B" from projects and folders ancestors.
+ * Excludes system containers (packages, workspaceRoots) and tasks.
  */
 export function getTreeHierarchyPath(tree, itemId) {
     const ancestors = getTreeAncestors(tree, itemId);
-    const hierarchyAncestors = ancestors.filter(a => a.itemType === 'Project' || a.itemType === 'Folder');
+    const hierarchyAncestors = ancestors.filter(a => a.itemType === 'projects' || a.itemType === 'folders');
     return hierarchyAncestors
         .map(a => a.name ?? `[${a.id}]`)
         .join(' › ');

package/dist/types.d.ts

@@ -8,7 +8,7 @@ import type { Result, RetryConfig, ClientConfig, EntityDef } from '@markwharton/
 /**
  * LiquidPlanner item types in the hierarchy
  */
-export type LPItemType = 'Task' | 'Assignment' | 'Folder' | 'Project' | 'Package' | 'WorkspaceRoot' | 'Milestone' | 'Event';
+export type LPItemType = 'workspaceRoots' | 'packages' | 'projects' | 'folders' | 'tasks' | 'assignments' | 'custom';
 /**
  * A generic hierarchy item for representing project/task paths.
  *
@@ -131,6 +131,8 @@ export interface LPWorkspace {
     /** Workspace name */
     name: string;
 }
+/** LiquidPlanner user type */
+export type LPUserType = 'member' | 'resource' | 'placeholder';
 /**
  * A workspace member from LiquidPlanner
  *
@@ -154,7 +156,7 @@ export interface LPMember {
     /** Last name */
     lastName: string;
     /** User type (member, resource, or placeholder) */
-    userType: 'member' | 'resource' | 'placeholder';
+    userType: LPUserType;
 }
 /**
  * Result of resolving an LP Item ID to the correct Assignment ID for logging time
@@ -243,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
  */

package/dist/utils.d.ts

@@ -1,7 +1,6 @@
 /**
  * LiquidPlanner Utility Functions
  */
-import type { LPItemType } from './types.js';
 import type { Result } from '@markwharton/api-core';
 /**
  * Build a URL-encoded filter for LP API: field[is]="value"
@@ -67,13 +66,6 @@ export declare function paginatedFetch<TRaw, TResult>(options: PaginateOptions<T
  * @throws Error if hours is not a valid non-negative number
  */
 export declare function hoursToMinutes(hours: number): number;
-/**
- * Normalize LP API itemType values to internal format
- *
- * LP API returns lowercase plural (e.g., "tasks", "assignments")
- * but our code uses PascalCase singular (e.g., "Task", "Assignment")
- */
-export declare function normalizeItemType(apiItemType: string): LPItemType;
 /**
  * Build the Authorization header for LP API requests
  */

package/dist/utils.js

@@ -124,35 +124,6 @@ export function hoursToMinutes(hours) {
     }
     return Math.round(hours * 60);
 }
-/**
- * Normalize LP API itemType values to internal format
- *
- * LP API returns lowercase plural (e.g., "tasks", "assignments")
- * but our code uses PascalCase singular (e.g., "Task", "Assignment")
- */
-export function normalizeItemType(apiItemType) {
-    const mapping = {
-        // LP API lowercase plural format
-        'tasks': 'Task',
-        'assignments': 'Assignment',
-        'folders': 'Folder',
-        'projects': 'Project',
-        'packages': 'Package',
-        'workspaceRoots': 'WorkspaceRoot',
-        'milestones': 'Milestone',
-        'events': 'Event',
-        // Already-normalized values (for safety)
-        'Task': 'Task',
-        'Assignment': 'Assignment',
-        'Folder': 'Folder',
-        'Project': 'Project',
-        'Package': 'Package',
-        'WorkspaceRoot': 'WorkspaceRoot',
-        'Milestone': 'Milestone',
-        'Event': 'Event',
-    };
-    return mapping[apiItemType] || apiItemType;
-}
 /**
  * Build the Authorization header for LP API requests
  */

package/dist/workflows.js

@@ -40,7 +40,7 @@ export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
     const itemResult = await client.getItem(itemId);
     if (!itemResult.ok || !itemResult.data) {
         return {
-            inputItem: { id: itemId, name: null, itemType: 'Task' },
+            inputItem: { id: itemId, name: null, itemType: 'tasks' },
             assignmentId: 0,
             error: itemResult.error || 'Item not found',
         };
@@ -48,7 +48,7 @@ export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
     const item = itemResult.data;
     // Step 2: Check item type and resolve accordingly
     switch (item.itemType) {
-        case 'Assignment':
+        case 'assignments':
             // Already an assignment, use it directly
             return {
                 inputItem: item,
@@ -56,7 +56,7 @@ export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
                 assignmentName: item.name ?? undefined,
                 assignmentUserId: item.userId,
             };
-        case 'Task': {
+        case 'tasks': {
             // Find assignments under this task
             const assignResult = await client.findAssignments(item.id);
             if (!assignResult.ok) {
@@ -119,19 +119,11 @@ export async function resolveTaskToAssignment(client, itemId, lpMemberId) {
                 multipleAssignments: assignments,
             };
         }
-        case 'Folder':
-        case 'Milestone':
-        case 'Event':
-            return {
-                inputItem: item,
-                assignmentId: 0,
-                error: `Cannot log time to a ${item.itemType}. Enter a Task or Assignment ID.`,
-            };
         default:
             return {
                 inputItem: item,
                 assignmentId: 0,
-                error: `Unsupported item type: ${item.itemType}`,
+                error: `Cannot log time to item type '${item.itemType}'. Provide a task or assignment ID.`,
             };
     }
 }

package/package.json

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