@markwharton/liquidplanner 1.8.1 → 1.9.0

package/README.md

@@ -0,0 +1,135 @@
+# @markwharton/liquidplanner
+
+LiquidPlanner API client for timesheet integration.
+
+## Install
+
+```bash
+npm install @markwharton/liquidplanner
+```
+
+## Quick Start
+
+```typescript
+import { LPClient, resolveTaskToAssignment } from '@markwharton/liquidplanner';
+
+const client = new LPClient({ apiToken: 'xxx', workspaceId: 123 });
+
+// Validate credentials
+await client.validateToken();
+
+// Get workspaces
+const { workspaces } = await client.getWorkspaces();
+
+// Get workspace members
+const { members } = await client.getWorkspaceMembers();
+
+// Get user's assignments (for task picker)
+const { assignments } = await client.getMyAssignments(memberId);
+
+// Get assignments with parent task/project names resolved
+const { assignments: enriched } = await client.getMyAssignmentsWithContext(memberId, {
+  includeProject: true  // optional: also fetch project names
+});
+
+// Get assignments with full hierarchy path
+const { assignments: withHierarchy } = await client.getMyAssignmentsWithContext(memberId, {
+  includeHierarchy: true  // includes ancestors and hierarchyPath
+});
+
+// Get item ancestors (hierarchy chain)
+const { ancestors } = await client.getItemAncestors(itemId);
+
+// Resolve task to assignment
+const resolution = await resolveTaskToAssignment(client, taskId, memberId);
+
+// Log time
+await client.createTimesheetEntry({
+  date: '2026-01-29',
+  itemId: resolution.assignmentId,
+  hours: 2.5,
+  note: 'Working on feature'
+});
+
+// Query existing entries for a date
+const { entries } = await client.getTimesheetEntries('2026-01-29', assignmentId);
+
+// Update an existing entry (accumulate hours)
+await client.updateTimesheetEntry(entryId, existingEntry, {
+  hours: existingEntry.hours + 1.5,
+  note: 'Additional work'
+});
+```
+
+## API Reference
+
+All methods return `{ data?, error? }` result objects rather than throwing exceptions.
+
+| Method | Parameters | Returns |
+|--------|-----------|---------|
+| `validateToken()` | — | `{ valid, error? }` |
+| `getWorkspaces()` | — | `{ workspaces?, error? }` |
+| `getWorkspaceMembers()` | — | `{ members?, error? }` |
+| `getItem(itemId)` | `number` | `{ item?, error? }` |
+| `getItems(itemIds)` | `number[]` | `{ items?, error? }` |
+| `getItemAncestors(itemId)` | `number` | `{ ancestors?, error? }` |
+| `findAssignments(taskId)` | `number` | `{ assignments?, error? }` |
+| `getMyAssignments(memberId)` | `number` | `{ assignments?, error? }` |
+| `getMyAssignmentsWithContext(memberId, options?)` | `number, { includeProject?, includeHierarchy? }` | `{ assignments?, error? }` |
+| `getCostCodes()` | — | `{ costCodes?, error? }` |
+| `createTimesheetEntry(entry)` | `LPTimesheetEntry` | `LPSyncResult` |
+| `getTimesheetEntries(date, itemId?)` | `string \| string[], number?` | `{ entries?, error? }` |
+| `updateTimesheetEntry(entryId, existing, updates)` | `number, LPTimesheetEntryWithId, Partial<LPTimesheetEntry>` | `LPSyncResult` |
+| `upsertTimesheetEntry(entry, options?)` | `LPTimesheetEntry, LPUpsertOptions?` | `LPSyncResult` |
+
+### Workflow: `resolveTaskToAssignment`
+
+```typescript
+import { resolveTaskToAssignment } from '@markwharton/liquidplanner';
+
+const resolution = await resolveTaskToAssignment(client, taskId, memberId);
+// resolution.assignmentId - the assignment ID to use for logging time
+```
+
+Resolves a Task ID to the correct Assignment ID for time logging. Handles cases where a task has multiple assignments by filtering on member ID.
+
+## Configuration
+
+```typescript
+const client = new LPClient({
+  apiToken: 'your-token',      // Required: Bearer token
+  workspaceId: 12345,          // Required: workspace ID
+  baseUrl: '...',              // Optional: override API base URL
+  onRequest: ({ method, url, description }) => { ... },  // Optional: debug callback
+  cache: {},                   // Optional: enable TTL caching (defaults below)
+  retry: {                     // Optional: retry on 429/503
+    maxRetries: 3,
+    initialDelayMs: 1000,
+    maxDelayMs: 10000,
+  },
+});
+```
+
+### Cache TTLs
+
+| Cache Key | Default TTL |
+|-----------|-------------|
+| 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.clearCache()` to manually clear all cached data.
+
+### Retry
+
+Automatically retries on HTTP 429 (Too Many Requests) and 503 (Service Unavailable) with exponential backoff. Respects the `Retry-After` header when present.
+
+## Architecture
+
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for design decisions, implementation patterns, and known limitations.
+
+## License
+
+MIT

package/dist/cache.d.ts

@@ -1,19 +1,27 @@
 /**
- * Simple in-memory TTL cache
+ * Simple in-memory TTL cache with request coalescing
  *
  * Provides per-instance memoization for LPClient API responses.
  * In serverless environments (Azure Functions, Static Web Apps),
  * module-level state persists across warm invocations within the
  * same instance — this cache leverages that behavior.
  *
+ * Request coalescing: when multiple concurrent callers request the
+ * same expired key, only one factory call is made. All callers
+ * receive the same resolved value (or the same rejection).
+ *
  * Not a distributed cache: each instance has its own cache.
  * Cold starts and instance recycling naturally clear stale data.
  */
 export declare class TTLCache {
     private store;
+    private inflight;
     /**
      * Get a cached value, or call the factory to populate it.
      *
+     * If a factory call is already in progress for this key,
+     * returns the existing promise instead of starting a duplicate.
+     *
      * @param key - Cache key
      * @param ttlMs - Time-to-live in milliseconds
      * @param factory - Async function to produce the value on cache miss
@@ -22,11 +30,14 @@ export declare class TTLCache {
     /**
      * Invalidate cache entries matching a key prefix.
      *
+     * Also cancels any in-flight requests for matching keys,
+     * so subsequent calls will start fresh factory invocations.
+     *
      * Example: invalidate('timesheet:') clears all timesheet entries.
      */
     invalidate(prefix: string): void;
     /**
-     * Clear all cached data.
+     * Clear all cached data and in-flight requests.
      */
     clear(): void;
 }

package/dist/cache.js

@@ -1,21 +1,29 @@
 /**
- * Simple in-memory TTL cache
+ * Simple in-memory TTL cache with request coalescing
  *
  * Provides per-instance memoization for LPClient API responses.
  * In serverless environments (Azure Functions, Static Web Apps),
  * module-level state persists across warm invocations within the
  * same instance — this cache leverages that behavior.
  *
+ * Request coalescing: when multiple concurrent callers request the
+ * same expired key, only one factory call is made. All callers
+ * receive the same resolved value (or the same rejection).
+ *
  * Not a distributed cache: each instance has its own cache.
  * Cold starts and instance recycling naturally clear stale data.
  */
 export class TTLCache {
     constructor() {
         this.store = new Map();
+        this.inflight = new Map();
     }
     /**
      * Get a cached value, or call the factory to populate it.
      *
+     * If a factory call is already in progress for this key,
+     * returns the existing promise instead of starting a duplicate.
+     *
      * @param key - Cache key
      * @param ttlMs - Time-to-live in milliseconds
      * @param factory - Async function to produce the value on cache miss
@@ -25,13 +33,27 @@ export class TTLCache {
         if (existing && existing.expiresAt > Date.now()) {
             return existing.data;
         }
-        const data = await factory();
-        this.store.set(key, { data, expiresAt: Date.now() + ttlMs });
-        return data;
+        const pending = this.inflight.get(key);
+        if (pending) {
+            return pending;
+        }
+        const promise = factory().then((data) => {
+            this.store.set(key, { data, expiresAt: Date.now() + ttlMs });
+            this.inflight.delete(key);
+            return data;
+        }, (err) => {
+            this.inflight.delete(key);
+            throw err;
+        });
+        this.inflight.set(key, promise);
+        return promise;
     }
     /**
      * Invalidate cache entries matching a key prefix.
      *
+     * Also cancels any in-flight requests for matching keys,
+     * so subsequent calls will start fresh factory invocations.
+     *
      * Example: invalidate('timesheet:') clears all timesheet entries.
      */
     invalidate(prefix) {
@@ -40,11 +62,17 @@ export class TTLCache {
                 this.store.delete(key);
             }
         }
+        for (const key of this.inflight.keys()) {
+            if (key.startsWith(prefix)) {
+                this.inflight.delete(key);
+            }
+        }
     }
     /**
-     * Clear all cached data.
+     * Clear all cached data and in-flight requests.
      */
     clear() {
         this.store.clear();
+        this.inflight.clear();
     }
 }

package/dist/client.d.ts

@@ -61,6 +61,14 @@ export declare class LPClient {
      * Respects the Retry-After header when present.
      */
     private fetch;
+    /**
+     * Build a workspace-scoped URL path.
+     */
+    private workspaceUrl;
+    /**
+     * Fetch a URL and parse the response, with standardized error handling.
+     */
+    private fetchAndParse;
     /**
      * Validate the API token by listing workspaces
      */

package/dist/client.js

@@ -6,10 +6,10 @@
  *
  * @see https://api-docs.liquidplanner.com/
  */
-import { buildAuthHeader, hoursToMinutes, normalizeItemType, filterIs, filterIn, paginatedFetch, batchMap, } from './utils.js';
-import { parseLPErrorResponse, getErrorMessage } from './errors.js';
+import { buildAuthHeader, hoursToMinutes, normalizeItemType, filterIs, filterIn, paginatedFetch, } from './utils.js';
+import { parseLPErrorResponse } from './errors.js';
 import { LP_API_BASE } from './constants.js';
-import { TTLCache } from './cache.js';
+import { TTLCache, batchMap, getErrorMessage, fetchWithRetry } from '@markwharton/api-core';
 /** Transform raw API item to LPItem */
 function transformItem(raw) {
     return {
@@ -104,47 +104,46 @@ export class LPClient {
         const { method = 'GET', body, description } = options;
         // Notify listener of request (for debugging)
         this.onRequest?.({ method, url, description });
-        const maxAttempts = this.retryConfig ? 1 + this.retryConfig.maxRetries : 1;
-        let lastResponse;
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            lastResponse = await fetch(url, {
-                method,
-                headers: {
-                    Authorization: buildAuthHeader(this.apiToken),
-                    'Content-Type': 'application/json',
-                },
-                body: body ? JSON.stringify(body) : undefined,
-            });
-            // Check if this is a retryable status
-            if (this.retryConfig && (lastResponse.status === 429 || lastResponse.status === 503)) {
-                if (attempt >= this.retryConfig.maxRetries) {
-                    return lastResponse; // Exhausted retries
-                }
-                // Calculate delay: respect Retry-After header, or use exponential backoff
-                let delayMs;
-                const retryAfterHeader = lastResponse.headers.get('Retry-After');
-                if (retryAfterHeader) {
-                    const retryAfterSeconds = parseInt(retryAfterHeader, 10);
-                    delayMs = Number.isFinite(retryAfterSeconds)
-                        ? retryAfterSeconds * 1000
-                        : this.retryConfig.initialDelayMs * Math.pow(2, attempt);
-                }
-                else {
-                    delayMs = this.retryConfig.initialDelayMs * Math.pow(2, attempt);
-                }
-                delayMs = Math.min(delayMs, this.retryConfig.maxDelayMs);
-                // Notify listener of retry (for debugging)
+        return fetchWithRetry(url, {
+            method,
+            headers: {
+                Authorization: buildAuthHeader(this.apiToken),
+                'Content-Type': 'application/json',
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        }, {
+            retry: this.retryConfig,
+            onRetry: ({ attempt, maxRetries, delayMs, status }) => {
                 this.onRequest?.({
                     method,
                     url,
-                    description: `Retry ${attempt + 1}/${this.retryConfig.maxRetries} after ${delayMs}ms (HTTP ${lastResponse.status})`,
+                    description: `Retry ${attempt}/${maxRetries} after ${delayMs}ms (HTTP ${status})`,
                 });
-                await new Promise(resolve => setTimeout(resolve, delayMs));
-                continue;
+            },
+        });
+    }
+    /**
+     * Build a workspace-scoped URL path.
+     */
+    workspaceUrl(path) {
+        return `${this.baseUrl}/workspaces/${this.workspaceId}/${path}`;
+    }
+    /**
+     * 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 { error: { message, statusCode: response.status, isDuplicate } };
             }
-            return lastResponse;
+            return { data: await parse(response) };
+        }
+        catch (error) {
+            return { error: { message: getErrorMessage(error), statusCode: 0 } };
         }
-        return lastResponse;
     }
     // ============================================================================
     // Workspace & Validation
@@ -173,23 +172,11 @@ export class LPClient {
      */
     async getWorkspaces() {
         const url = `${this.baseUrl}/workspaces/v1`;
-        try {
-            const response = await this.fetch(url);
-            if (!response.ok) {
-                const errorText = await response.text();
-                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
-                return { error: { message, statusCode: response.status, isDuplicate } };
-            }
-            const result = await response.json();
-            const workspaces = (result.data || []).map(ws => ({
-                id: ws.id,
-                name: ws.name,
-            }));
-            return { workspaces };
-        }
-        catch (error) {
-            return { error: { message: getErrorMessage(error), statusCode: 0 } };
-        }
+        const { data, error } = await this.fetchAndParse(url, async (r) => {
+            const result = await r.json();
+            return (result.data || []).map(ws => ({ id: ws.id, name: ws.name }));
+        });
+        return error ? { error } : { workspaces: data };
     }
     // ============================================================================
     // Members
@@ -199,7 +186,7 @@ export class LPClient {
      */
     async getWorkspaceMembers() {
         return this.cached('members', this.cacheTtl.membersTtl, async () => {
-            const baseUrl = `${this.baseUrl}/workspaces/${this.workspaceId}/users/v1`;
+            const baseUrl = this.workspaceUrl('users/v1');
             const { results, error } = await paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
@@ -223,23 +210,18 @@ export class LPClient {
      */
     async getItem(itemId) {
         return this.cached(`item:${itemId}`, this.cacheTtl.itemsTtl, async () => {
-            const url = `${this.baseUrl}/workspaces/${this.workspaceId}/items/v1?${filterIs('id', itemId)}`;
-            try {
-                const response = await this.fetch(url);
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
-                    return { error: { message, statusCode: response.status, isDuplicate } };
-                }
-                const result = await response.json();
-                if (!result.data || result.data.length === 0) {
-                    return { error: { message: `Item ${itemId} not found`, statusCode: 404 } };
-                }
-                return { item: transformItem(result.data[0]) };
-            }
-            catch (error) {
-                return { error: { message: getErrorMessage(error), statusCode: 0 } };
-            }
+            const url = this.workspaceUrl(`items/v1?${filterIs('id', itemId)}`);
+            const { data, error } = await this.fetchAndParse(url, async (r) => {
+                const result = await r.json();
+                if (!result.data || result.data.length === 0)
+                    return null;
+                return transformItem(result.data[0]);
+            });
+            if (error)
+                return { error };
+            if (!data)
+                return { error: { message: `Item ${itemId} not found`, statusCode: 404 } };
+            return { item: data };
         });
     }
     /**
@@ -253,7 +235,7 @@ export class LPClient {
     async getItems(itemIds) {
         if (itemIds.length === 0)
             return { items: [] };
-        const baseUrl = `${this.baseUrl}/workspaces/${this.workspaceId}/items/v1?${filterIn('id', itemIds)}`;
+        const baseUrl = this.workspaceUrl(`items/v1?${filterIn('id', itemIds)}`);
         const { results, error } = await paginatedFetch({
             fetchFn: (url) => this.fetch(url),
             baseUrl,
@@ -271,29 +253,18 @@ export class LPClient {
      */
     async getItemAncestors(itemId) {
         return this.cached(`ancestors:${itemId}`, this.cacheTtl.itemsTtl, async () => {
-            const url = `${this.baseUrl}/workspaces/${this.workspaceId}/items/v1/${itemId}/ancestors`;
-            try {
-                const response = await this.fetch(url, {
-                    description: `Get ancestors for item ${itemId}`,
-                });
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
-                    return { error: { message, statusCode: response.status, isDuplicate } };
-                }
-                const json = (await response.json());
+            const url = this.workspaceUrl(`items/v1/${itemId}/ancestors`);
+            const { data, error } = await this.fetchAndParse(url, async (r) => {
+                const json = (await r.json());
                 // Handle both { data: [...] } and direct array responses
                 const rawData = Array.isArray(json) ? json : (json.data || []);
-                const ancestors = rawData.map((a) => ({
+                return rawData.map((a) => ({
                     id: a.id,
                     name: a.name || null,
                     itemType: normalizeItemType(a.itemType),
                 })).reverse(); // LP API returns child→root, normalize to root→child
-                return { ancestors };
-            }
-            catch (error) {
-                return { error: { message: getErrorMessage(error), statusCode: 0 } };
-            }
+            }, { description: `Get ancestors for item ${itemId}` });
+            return error ? { error } : { ancestors: data };
         });
     }
     /**
@@ -301,7 +272,7 @@ export class LPClient {
      */
     async findAssignments(taskId) {
         // parentId[is]="{taskId}"&itemType[is]="assignments" (LP API uses lowercase plural)
-        const baseUrl = `${this.baseUrl}/workspaces/${this.workspaceId}/items/v1?${filterIs('parentId', taskId)}&${filterIs('itemType', 'assignments')}`;
+        const baseUrl = this.workspaceUrl(`items/v1?${filterIs('parentId', taskId)}&${filterIs('itemType', 'assignments')}`);
         const { results, error } = await paginatedFetch({
             fetchFn: (url) => this.fetch(url),
             baseUrl,
@@ -317,7 +288,7 @@ export class LPClient {
      */
     async getMyAssignments(memberId) {
         return this.cached(`assignments:${memberId}`, this.cacheTtl.assignmentsTtl, async () => {
-            const baseUrl = `${this.baseUrl}/workspaces/${this.workspaceId}/items/v1?${filterIs('itemType', 'assignments')}`;
+            const baseUrl = this.workspaceUrl(`items/v1?${filterIs('itemType', 'assignments')}`);
             const { results, error } = await paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
@@ -455,7 +426,7 @@ export class LPClient {
      */
     async getCostCodes() {
         return this.cached('costcodes', this.cacheTtl.costCodesTtl, async () => {
-            const baseUrl = `${this.baseUrl}/workspaces/${this.workspaceId}/cost-codes/v1`;
+            const baseUrl = this.workspaceUrl('cost-codes/v1');
             const { results, error } = await paginatedFetch({
                 fetchFn: (url) => this.fetch(url),
                 baseUrl,
@@ -479,7 +450,7 @@ export class LPClient {
      */
     async createTimesheetEntry(entry) {
         const { date, itemId, hours, costCodeId, note } = entry;
-        const url = `${this.baseUrl}/workspaces/${this.workspaceId}/logged-time-entries/v1`;
+        const url = this.workspaceUrl('logged-time-entries/v1');
         // Build request body according to LP Logged Time Entries API
         const body = {
             date,
@@ -494,21 +465,15 @@ export class LPClient {
         if (note) {
             body.note = note;
         }
-        try {
-            const response = await this.fetch(url, { method: 'POST', body });
-            if (!response.ok) {
-                const errorText = await response.text();
-                const { message, isDuplicate } = parseLPErrorResponse(errorText, response.status);
-                return { success: false, error: message, statusCode: response.status, isDuplicate };
-            }
-            // Invalidate cached timesheet entries for this date
-            this.cache?.invalidate(`timesheet:`);
-            const result = await response.json();
-            return { success: true, entryId: result.id };
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error), statusCode: 0 };
+        const { data, error } = await this.fetchAndParse(url, async (r) => {
+            this.cache?.invalidate('timesheet:');
+            const result = await r.json();
+            return result.id;
+        }, { method: 'POST', body });
+        if (error) {
+            return { success: false, error: error.message, statusCode: error.statusCode, isDuplicate: error.isDuplicate };
         }
+        return { success: true, entryId: data };
     }
     /**
      * Get timesheet entries for one or more dates
@@ -530,7 +495,7 @@ export class LPClient {
         const cacheKey = itemId ? `timesheet:${sortedKey}:${itemId}` : `timesheet:${sortedKey}`;
         return this.cached(cacheKey, this.cacheTtl.timesheetTtl, async () => {
             // Build query with date[in] filter (supports multiple dates)
-            let baseUrl = `${this.baseUrl}/workspaces/${this.workspaceId}/logged-time-entries/v1?${filterIn('date', dates)}`;
+            let baseUrl = this.workspaceUrl(`logged-time-entries/v1?${filterIn('date', dates)}`);
             // Optional filter by itemId
             if (itemId) {
                 baseUrl += `&${filterIs('itemId', itemId)}`;
@@ -571,7 +536,7 @@ export class LPClient {
      * @param updates - Fields to update (merged with existing)
      */
     async updateTimesheetEntry(entryId, existingEntry, updates) {
-        const url = `${this.baseUrl}/workspaces/${this.workspaceId}/logged-time-entries/v1/${entryId}`;
+        const url = this.workspaceUrl(`logged-time-entries/v1/${entryId}`);
         // PUT requires all fields - merge updates with existing entry
         // IMPORTANT: LP API appends the note field, so only send new notes
         // If no new note, send empty string to avoid re-appending existing notes
@@ -584,20 +549,13 @@ export class LPClient {
             note: updates.note ?? '',
             userId: existingEntry.userId,
         };
-        try {
-            const response = await this.fetch(url, { method: 'PUT', body });
-            if (!response.ok) {
-                const errorText = await response.text();
-                const { message } = parseLPErrorResponse(errorText, response.status);
-                return { success: false, error: message, statusCode: response.status };
-            }
-            // Invalidate cached timesheet entries
-            this.cache?.invalidate(`timesheet:`);
-            return { success: true, entryId };
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error), statusCode: 0 };
+        const { error } = await this.fetchAndParse(url, async () => {
+            this.cache?.invalidate('timesheet:');
+        }, { method: 'PUT', body });
+        if (error) {
+            return { success: false, error: error.message, statusCode: error.statusCode, isDuplicate: error.isDuplicate };
         }
+        return { success: true, entryId };
     }
     /**
      * Create or update a timesheet entry (upsert)

package/dist/errors.d.ts

@@ -42,7 +42,3 @@ export declare class LPError extends Error {
      */
     static fromResponse(statusCode: number, responseText: string): LPError;
 }
-/**
- * Get a safe error message from any error type
- */
-export declare function getErrorMessage(error: unknown): string;

package/dist/errors.js

@@ -8,8 +8,6 @@
  */
 /** Error code for duplicate entry errors */
 const LP_ERROR_CODE_DUPLICATE = 'duplicate_value';
-/** Default error message when none is available */
-const DEFAULT_ERROR_MESSAGE = 'Unknown error';
 /**
  * Parse LP API error response text into a human-readable message.
  *
@@ -59,12 +57,3 @@ export class LPError extends Error {
         });
     }
 }
-/**
- * Get a safe error message from any error type
- */
-export function getErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return DEFAULT_ERROR_MESSAGE;
-}

package/dist/index.d.ts

@@ -29,8 +29,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, LPResult, LPUpsertOptions, LPAssignmentWithContext, LPErrorInfo, } from './types.js';
-export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIn, paginatedFetch, batchMap, } from './utils.js';
+export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIn, paginatedFetch, } from './utils.js';
 export type { PaginateOptions } from './utils.js';
+export { batchMap, getErrorMessage } from '@markwharton/api-core';
 export { LP_API_BASE } from './constants.js';
-export { LPError, parseLPErrorResponse, getErrorMessage } from './errors.js';
+export { LPError, parseLPErrorResponse } from './errors.js';
 export type { LPParsedError } from './errors.js';

package/dist/index.js

@@ -31,8 +31,9 @@ export { LPClient } from './client.js';
 // Workflows
 export { resolveTaskToAssignment } from './workflows.js';
 // Utilities
-export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIn, paginatedFetch, batchMap, } from './utils.js';
+export { hoursToMinutes, normalizeItemType, buildAuthHeader, filterIs, filterIn, paginatedFetch, } from './utils.js';
+export { batchMap, getErrorMessage } from '@markwharton/api-core';
 // Constants
 export { LP_API_BASE } from './constants.js';
 // Errors
-export { LPError, parseLPErrorResponse, getErrorMessage } from './errors.js';
+export { LPError, parseLPErrorResponse } from './errors.js';

package/dist/utils.d.ts

@@ -54,16 +54,3 @@ export declare function normalizeItemType(apiItemType: string): LPItemType;
  * Build the Authorization header for LP API requests
  */
 export declare function buildAuthHeader(apiToken: string): string;
-/**
- * Map over items with bounded concurrency
- *
- * Processes items in batches of `concurrency`, waiting for each batch
- * to complete before starting the next. This prevents overwhelming
- * APIs with too many simultaneous requests.
- *
- * @param items - Array of items to process
- * @param concurrency - Maximum number of concurrent operations
- * @param fn - Async function to apply to each item
- * @returns Array of results in the same order as input items
- */
-export declare function batchMap<T, R>(items: T[], concurrency: number, fn: (item: T) => Promise<R>): Promise<R[]>;

package/dist/utils.js

@@ -1,7 +1,8 @@
 /**
  * LiquidPlanner Utility Functions
  */
-import { parseLPErrorResponse, getErrorMessage } from './errors.js';
+import { parseLPErrorResponse } from './errors.js';
+import { getErrorMessage } from '@markwharton/api-core';
 // ============================================================================
 // LP API Filter Builders
 // ============================================================================
@@ -104,27 +105,3 @@ export function normalizeItemType(apiItemType) {
 export function buildAuthHeader(apiToken) {
     return `Bearer ${apiToken}`;
 }
-// ============================================================================
-// Concurrency Helper
-// ============================================================================
-/**
- * Map over items with bounded concurrency
- *
- * Processes items in batches of `concurrency`, waiting for each batch
- * to complete before starting the next. This prevents overwhelming
- * APIs with too many simultaneous requests.
- *
- * @param items - Array of items to process
- * @param concurrency - Maximum number of concurrent operations
- * @param fn - Async function to apply to each item
- * @returns Array of results in the same order as input items
- */
-export async function batchMap(items, concurrency, fn) {
-    const results = [];
-    for (let i = 0; i < items.length; i += concurrency) {
-        const batch = items.slice(i, i + concurrency);
-        const batchResults = await Promise.all(batch.map(fn));
-        results.push(...batchResults);
-    }
-    return results;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markwharton/liquidplanner",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "LiquidPlanner API client for timesheet integration",
   "type": "module",
   "main": "dist/index.js",
@@ -15,6 +15,9 @@
     "build": "tsc",
     "clean": "rm -rf dist"
   },
+  "dependencies": {
+    "@markwharton/api-core": "^1.0.0"
+  },
   "devDependencies": {
     "@types/node": "^20.10.0",
     "typescript": "^5.3.0"
@@ -27,6 +30,9 @@
     "url": "git+https://github.com/MarkWharton/api-packages.git",
     "directory": "packages/liquidplanner"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "author": "Mark Wharton",
   "license": "MIT",
   "engines": {