@brownandroot/api 1.2.1 → 2.0.0

package/dist/cache.d.ts

@@ -97,46 +97,34 @@ export interface JobtypejobstepFilters {
     /** Case-insensitive partial match on description, jobType, or jobStep */
     q?: string;
 }
-export declare function getEmployees(filters?: EmployeeFilters): Promise<Employee[]>;
-export declare function getEmployeesDropdown(filters?: EmployeeFilters): Promise<DropdownOption[]>;
-/** Single employee by ID — always fetches fresh (no IndexedDB). */
-export declare function getEmployee(employeeId: string): Promise<Employee>;
+declare function getEmployees(filters?: EmployeeFilters): Promise<Employee[]>;
+declare function getEmployeesDropdown(filters?: EmployeeFilters): Promise<DropdownOption[]>;
 /** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
-export declare function getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
+declare function getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
 /** Full supervisor chain above an employee — always fetches fresh. */
-export declare function getSupervisorChain(employeeId: string): Promise<Employee[]>;
+declare function getSupervisorChain(employeeId: string): Promise<Employee[]>;
 /** Look up JDE number and employee from email — always fetches fresh. */
-export declare function getJdeFromEmail(email: string): Promise<{
+declare function getJdeFromEmail(email: string): Promise<{
     jde: string | null;
     employee: Employee | null;
 }>;
 /** Verify employee identity — always fetches fresh. */
-export declare function verifyIdentity(inputs: {
+declare function verifyIdentity(inputs: {
     first3FirstName: string;
     first3LastName: string;
     dob: string;
     ssn4: string;
 }): Promise<Employee | null>;
-export declare function getWorkorders(filters?: WorkorderFilters): Promise<Workorder[]>;
-export declare function getWorkordersDropdown(filters?: WorkorderFilters): Promise<DropdownOption[]>;
-/** Single workorder by ID — always fetches fresh (no IndexedDB). */
-export declare function getWorkorder(id: string): Promise<Workorder>;
-export declare function getCostcodes(filters?: CostcodeFilters): Promise<Costcode[]>;
-export declare function getCostcodesDropdown(filters?: CostcodeFilters): Promise<DropdownOption[]>;
-/** Single cost code by ID — always fetches fresh (no IndexedDB). */
-export declare function getCostcode(id: string): Promise<Costcode>;
-export declare function getPaytypes(filters?: PaytypeFilters): Promise<Paytype[]>;
-export declare function getPaytypesDropdown(filters?: PaytypeFilters): Promise<PaytypeDropdownOption[]>;
-/** Single pay type by ID — always fetches fresh (no IndexedDB). */
-export declare function getPaytype(id: string): Promise<Paytype>;
-export declare function getBusinessUnits(filters?: BusinessUnitFilters): Promise<BusinessUnit[]>;
-export declare function getBusinessUnitsDropdown(filters?: BusinessUnitFilters): Promise<DropdownOption[]>;
-/** Single business unit by ID — always fetches fresh (no IndexedDB). */
-export declare function getBusinessUnit(id: string): Promise<BusinessUnit>;
-export declare function getJobtypejobsteps(filters?: JobtypejobstepFilters): Promise<Jobtypejobstep[]>;
-export declare function getJobtypejobstepsDropdown(filters?: JobtypejobstepFilters): Promise<DropdownOption[]>;
-/** Single job type/job step by ID — always fetches fresh (no IndexedDB). */
-export declare function getJobtypejobstep(id: string): Promise<Jobtypejobstep>;
+declare function getWorkorders(filters?: WorkorderFilters): Promise<Workorder[]>;
+declare function getWorkordersDropdown(filters?: WorkorderFilters): Promise<DropdownOption[]>;
+declare function getCostcodes(filters?: CostcodeFilters): Promise<Costcode[]>;
+declare function getCostcodesDropdown(filters?: CostcodeFilters): Promise<DropdownOption[]>;
+declare function getPaytypes(filters?: PaytypeFilters): Promise<Paytype[]>;
+declare function getPaytypesDropdown(filters?: PaytypeFilters): Promise<PaytypeDropdownOption[]>;
+declare function getBusinessUnits(filters?: BusinessUnitFilters): Promise<BusinessUnit[]>;
+declare function getBusinessUnitsDropdown(filters?: BusinessUnitFilters): Promise<DropdownOption[]>;
+declare function getJobtypejobsteps(filters?: JobtypejobstepFilters): Promise<Jobtypejobstep[]>;
+declare function getJobtypejobstepsDropdown(filters?: JobtypejobstepFilters): Promise<DropdownOption[]>;
 /**
  * Clear the IndexedDB cache for a specific entity, or all entities.
  *
@@ -150,3 +138,38 @@ export declare function getJobtypejobstep(id: string): Promise<Jobtypejobstep>;
  * clearCache()  // clear everything
  */
 export declare function clearCache(entity?: IdbStore): void;
+export declare const employees: {
+    getAll: typeof getEmployees;
+    dropdown: typeof getEmployeesDropdown;
+    get: (id: string) => Promise<Employee | null>;
+    getPrivileged: typeof getEmployeePrivileged;
+    getSupervisorChain: typeof getSupervisorChain;
+    getJdeFromEmail: typeof getJdeFromEmail;
+    verifyIdentity: typeof verifyIdentity;
+};
+export declare const workorders: {
+    getAll: typeof getWorkorders;
+    dropdown: typeof getWorkordersDropdown;
+    get: (id: string) => Promise<Workorder | null>;
+};
+export declare const costcodes: {
+    getAll: typeof getCostcodes;
+    dropdown: typeof getCostcodesDropdown;
+    get: (id: string) => Promise<Costcode | null>;
+};
+export declare const paytypes: {
+    getAll: typeof getPaytypes;
+    dropdown: typeof getPaytypesDropdown;
+    get: (id: string) => Promise<Paytype | null>;
+};
+export declare const businessUnits: {
+    getAll: typeof getBusinessUnits;
+    dropdown: typeof getBusinessUnitsDropdown;
+    get: (id: string) => Promise<BusinessUnit | null>;
+};
+export declare const jobtypejobsteps: {
+    getAll: typeof getJobtypejobsteps;
+    dropdown: typeof getJobtypejobstepsDropdown;
+    get: (id: string) => Promise<Jobtypejobstep | null>;
+};
+export {};

package/dist/cache.js

@@ -9,18 +9,36 @@
  */
 import { idbGet, idbSet, idbClear } from './idb.js';
 // Remote functions — called as HTTP on the client, directly on the server (SSR)
-import { getEmployees as _getEmployees, getEmployee as _getEmployee, getEmployeePrivileged as _getEmployeePrivileged, getJdeFromEmail as _getJdeFromEmail, getSupervisorChain as _getSupervisorChain, verifyIdentity as _verifyIdentity, } from './employees.remote.js';
-import { getBusinessUnits as _getBusinessUnits, getBusinessUnit as _getBusinessUnit } from './businessUnits.remote.js';
-import { getCostcodes as _getCostcodes, getCostcode as _getCostcode } from './costcodes.remote.js';
-import { getPaytypes as _getPaytypes, getPaytype as _getPaytype } from './paytypes.remote.js';
-import { getWorkorders as _getWorkorders, getWorkorder as _getWorkorder } from './workorders.remote.js';
-import { getJobtypejobsteps as _getJobtypejobsteps, getJobtypejobstep as _getJobtypejobstep, } from './jobtypejobsteps.remote.js';
+import { employees as remoteEmployees } from './employees.remote.js';
+import { businessUnits as remoteBusinessUnits } from './businessUnits.remote.js';
+import { costcodes as remoteCostcodes } from './costcodes.remote.js';
+import { paytypes as remotePaytypes } from './paytypes.remote.js';
+import { workorders as remoteWorkorders } from './workorders.remote.js';
+import { jobtypejobsteps as remoteJobtypejobsteps } from './jobtypejobsteps.remote.js';
 // ---------------------------------------------------------------------------
 // Internal: stale-while-revalidate fetch helpers
 // ---------------------------------------------------------------------------
 /** How long cached data is considered fresh before a background refresh is triggered. */
 const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+/** Server-side in-memory cache TTL for SSR/BFF usage. */
+const SERVER_CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
+const serverCache = new Map();
+function logReadFailure(operation, error) {
+    if (typeof window !== 'undefined')
+        return;
+    const detail = error instanceof Error ? { name: error.name, message: error.message } : { error };
+    console.error(`[APIHubReadFailOpen] ${operation}`, detail);
+}
 async function loadCached(store, fetcher) {
+    if (typeof window === 'undefined') {
+        const cached = serverCache.get(store);
+        if (cached && Date.now() - cached.fetchedAt < SERVER_CACHE_TTL_MS) {
+            return cached.data;
+        }
+        const data = await fetcher();
+        serverCache.set(store, { data, fetchedAt: Date.now() });
+        return data;
+    }
     const cached = await idbGet(store, 'all');
     if (cached) {
         // Only refresh in the background if the cached data is older than the TTL
@@ -167,7 +185,7 @@ async function applyCostcodeFilters(data, f) {
     // Resolve payTypeCode → objectAccount
     let payTypeObjectAccount;
     if (f.payTypeCode !== undefined) {
-        const allPaytypes = await loadCached('paytypes', () => _getPaytypes());
+        const allPaytypes = await loadCached('paytypes', () => remotePaytypes.getAll());
         payTypeObjectAccount = allPaytypes.find((p) => p.id === f.payTypeCode)?.objectAccount;
     }
     return data.filter((c) => {
@@ -195,57 +213,102 @@ async function applyCostcodeFilters(data, f) {
 // ---------------------------------------------------------------------------
 // Public API — Employees
 // ---------------------------------------------------------------------------
-export async function getEmployees(filters) {
-    const all = await loadCached('employees', () => _getEmployees());
+async function getEmployees(filters) {
+    let all;
+    try {
+        all = await loadCached('employees', () => remoteEmployees.getAll());
+    }
+    catch (error) {
+        logReadFailure('employees.getAll', error);
+        return [];
+    }
     return applyEmployeeFilters(all, filters);
 }
-export async function getEmployeesDropdown(filters) {
+async function getEmployeesDropdown(filters) {
     const results = await getEmployees(filters);
     return results.map((e) => ({ value: e.employeeId, label: e.name ?? e.employeeId }));
 }
 /** Single employee by ID — always fetches fresh (no IndexedDB). */
-export async function getEmployee(employeeId) {
-    return _getEmployee(employeeId);
+async function getEmployee(employeeId) {
+    try {
+        return await remoteEmployees.get(employeeId);
+    }
+    catch (error) {
+        logReadFailure('employees.get', error);
+        return null;
+    }
 }
 /** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
-export async function getEmployeePrivileged(employeeId) {
-    return _getEmployeePrivileged(employeeId);
+async function getEmployeePrivileged(employeeId) {
+    return remoteEmployees.getPrivileged(employeeId);
 }
 /** Full supervisor chain above an employee — always fetches fresh. */
-export async function getSupervisorChain(employeeId) {
-    return _getSupervisorChain(employeeId);
+async function getSupervisorChain(employeeId) {
+    try {
+        return await remoteEmployees.getSupervisorChain(employeeId);
+    }
+    catch (error) {
+        logReadFailure('employees.getSupervisorChain', error);
+        return [];
+    }
 }
 /** Look up JDE number and employee from email — always fetches fresh. */
-export async function getJdeFromEmail(email) {
-    return _getJdeFromEmail(email);
+async function getJdeFromEmail(email) {
+    try {
+        return await remoteEmployees.getJdeFromEmail(email);
+    }
+    catch (error) {
+        logReadFailure('employees.getJdeFromEmail', error);
+        return { jde: null, employee: null };
+    }
 }
 /** Verify employee identity — always fetches fresh. */
-export async function verifyIdentity(inputs) {
-    return _verifyIdentity(inputs);
+async function verifyIdentity(inputs) {
+    return remoteEmployees.verifyIdentity(inputs);
 }
 // ---------------------------------------------------------------------------
 // Public API — Workorders
 // ---------------------------------------------------------------------------
-export async function getWorkorders(filters) {
-    const all = await loadCached('workorders', () => _getWorkorders());
+async function getWorkorders(filters) {
+    let all;
+    try {
+        all = await loadCached('workorders', () => remoteWorkorders.getAll());
+    }
+    catch (error) {
+        logReadFailure('workorders.getAll', error);
+        return [];
+    }
     return applyWorkorderFilters(all, filters);
 }
-export async function getWorkordersDropdown(filters) {
+async function getWorkordersDropdown(filters) {
     const results = await getWorkorders({ isActive: true, ...filters });
     return results.map((w) => ({ value: w.id, label: w.description ?? w.id }));
 }
 /** Single workorder by ID — always fetches fresh (no IndexedDB). */
-export async function getWorkorder(id) {
-    return _getWorkorder(id);
+async function getWorkorder(id) {
+    try {
+        return await remoteWorkorders.get(id);
+    }
+    catch (error) {
+        logReadFailure('workorders.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Cost Codes
 // ---------------------------------------------------------------------------
-export async function getCostcodes(filters) {
-    const all = await loadCached('costcodes', () => _getCostcodes());
+async function getCostcodes(filters) {
+    let all;
+    try {
+        all = await loadCached('costcodes', () => remoteCostcodes.getAll());
+    }
+    catch (error) {
+        logReadFailure('costcodes.getAll', error);
+        return [];
+    }
     return applyCostcodeFilters(all, filters);
 }
-export async function getCostcodesDropdown(filters) {
+async function getCostcodesDropdown(filters) {
     const mergedFilters = { isActive: true, entryFlag: true, ...filters };
     const results = await getCostcodes(mergedFilters);
     const now = new Date();
@@ -257,56 +320,104 @@ export async function getCostcodesDropdown(filters) {
     }));
 }
 /** Single cost code by ID — always fetches fresh (no IndexedDB). */
-export async function getCostcode(id) {
-    return _getCostcode(id);
+async function getCostcode(id) {
+    try {
+        return await remoteCostcodes.get(id);
+    }
+    catch (error) {
+        logReadFailure('costcodes.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Pay Types
 // ---------------------------------------------------------------------------
-export async function getPaytypes(filters) {
-    const all = await loadCached('paytypes', () => _getPaytypes());
+async function getPaytypes(filters) {
+    let all;
+    try {
+        all = await loadCached('paytypes', () => remotePaytypes.getAll());
+    }
+    catch (error) {
+        logReadFailure('paytypes.getAll', error);
+        return [];
+    }
     return applyPaytypeFilters(all, filters);
 }
-export async function getPaytypesDropdown(filters) {
-    const results = await getPaytypes(filters);
+async function getPaytypesDropdown(filters) {
+    const mergedFilters = { isActive: true, ...filters };
+    const results = await getPaytypes(mergedFilters);
     return results.map((p) => ({ value: p.id, label: p.description, payClass: p.payClass }));
 }
 /** Single pay type by ID — always fetches fresh (no IndexedDB). */
-export async function getPaytype(id) {
-    return _getPaytype(id);
+async function getPaytype(id) {
+    try {
+        return await remotePaytypes.get(id);
+    }
+    catch (error) {
+        logReadFailure('paytypes.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Business Units
 // ---------------------------------------------------------------------------
-export async function getBusinessUnits(filters) {
-    const all = await loadCached('businessUnits', () => _getBusinessUnits());
+async function getBusinessUnits(filters) {
+    let all;
+    try {
+        all = await loadCached('businessUnits', () => remoteBusinessUnits.getAll());
+    }
+    catch (error) {
+        logReadFailure('businessUnits.getAll', error);
+        return [];
+    }
     return applyBusinessUnitFilters(all, filters);
 }
-export async function getBusinessUnitsDropdown(filters) {
-    const results = await getBusinessUnits(filters);
+async function getBusinessUnitsDropdown(filters) {
+    const mergedFilters = { isActive: true, ...filters };
+    const results = await getBusinessUnits(mergedFilters);
     return results.map((b) => ({ value: b.id, label: b.description }));
 }
 /** Single business unit by ID — always fetches fresh (no IndexedDB). */
-export async function getBusinessUnit(id) {
-    return _getBusinessUnit(id);
+async function getBusinessUnit(id) {
+    try {
+        return await remoteBusinessUnits.get(id);
+    }
+    catch (error) {
+        logReadFailure('businessUnits.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API — Job Type / Job Steps
 // ---------------------------------------------------------------------------
-export async function getJobtypejobsteps(filters) {
-    const all = await loadCached('jobtypejobsteps', () => _getJobtypejobsteps());
+async function getJobtypejobsteps(filters) {
+    let all;
+    try {
+        all = await loadCached('jobtypejobsteps', () => remoteJobtypejobsteps.getAll());
+    }
+    catch (error) {
+        logReadFailure('jobtypejobsteps.getAll', error);
+        return [];
+    }
     return applyJobtypejobstepFilters(all, filters);
 }
-export async function getJobtypejobstepsDropdown(filters) {
-    const results = await getJobtypejobsteps(filters);
+async function getJobtypejobstepsDropdown(filters) {
+    const mergedFilters = { isActive: true, ...filters };
+    const results = await getJobtypejobsteps(mergedFilters);
     return results.map((j) => ({
         value: j.id,
         label: j.description ?? `${j.jobType ?? ''} ${j.jobStep ?? ''}`.trim(),
     }));
 }
 /** Single job type/job step by ID — always fetches fresh (no IndexedDB). */
-export async function getJobtypejobstep(id) {
-    return _getJobtypejobstep(id);
+async function getJobtypejobstep(id) {
+    try {
+        return await remoteJobtypejobsteps.get(id);
+    }
+    catch (error) {
+        logReadFailure('jobtypejobsteps.get', error);
+        return null;
+    }
 }
 // ---------------------------------------------------------------------------
 // Cache management
@@ -324,5 +435,48 @@ export async function getJobtypejobstep(id) {
  * clearCache()  // clear everything
  */
 export function clearCache(entity) {
+    if (entity) {
+        serverCache.delete(entity);
+    }
+    else {
+        serverCache.clear();
+    }
     idbClear(entity).catch(() => { });
 }
+// ---------------------------------------------------------------------------
+// Unified domain-style API (v2 contract)
+// ---------------------------------------------------------------------------
+export const employees = {
+    getAll: getEmployees,
+    dropdown: getEmployeesDropdown,
+    get: (id) => getEmployee(id),
+    getPrivileged: getEmployeePrivileged,
+    getSupervisorChain,
+    getJdeFromEmail,
+    verifyIdentity,
+};
+export const workorders = {
+    getAll: getWorkorders,
+    dropdown: getWorkordersDropdown,
+    get: (id) => getWorkorder(id),
+};
+export const costcodes = {
+    getAll: getCostcodes,
+    dropdown: getCostcodesDropdown,
+    get: (id) => getCostcode(id),
+};
+export const paytypes = {
+    getAll: getPaytypes,
+    dropdown: getPaytypesDropdown,
+    get: (id) => getPaytype(id),
+};
+export const businessUnits = {
+    getAll: getBusinessUnits,
+    dropdown: getBusinessUnitsDropdown,
+    get: (id) => getBusinessUnit(id),
+};
+export const jobtypejobsteps = {
+    getAll: getJobtypejobsteps,
+    dropdown: getJobtypejobstepsDropdown,
+    get: (id) => getJobtypejobstep(id),
+};

package/dist/costcodes.remote.d.ts

@@ -1,3 +1,5 @@
-export declare const getCostcodes: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Costcode[]>;
-export declare const getCostcodesDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
-export declare const getCostcode: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Costcode>;
+export declare const costcodes: {
+    getAll: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Costcode[]>;
+    dropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
+    get: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Costcode | null>;
+};

package/dist/costcodes.remote.js

@@ -1,6 +1,26 @@
 import { query } from '$app/server';
 import { z } from 'zod';
 import { getClient } from './client.js';
-export const getCostcodes = query(async () => getClient().getCostcodes());
-export const getCostcodesDropdown = query(async () => getClient().getCostcodesDropdown());
-export const getCostcode = query(z.string(), async (id) => getClient().getCostcode(id));
+function isNotFoundError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /not found/i.test(error.message);
+}
+async function asNullable(fetcher) {
+    try {
+        return await fetcher();
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+}
+const getAll = query(async () => getClient().getCostcodes());
+const dropdown = query(async () => getClient().getCostcodesDropdown());
+const get = query(z.string(), async (id) => asNullable(() => getClient().getCostcode(id)));
+export const costcodes = {
+    getAll,
+    dropdown,
+    get,
+};

package/dist/employees.remote.d.ts

@@ -1,15 +1,17 @@
-export declare const getEmployees: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Employee[]>;
-export declare const getEmployeesDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
-export declare const getEmployee: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee>;
-export declare const getEmployeePrivileged: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").EmployeePrivileged>;
-export declare const getSupervisorChain: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
-export declare const getJdeFromEmail: import("@sveltejs/kit").RemoteQueryFunction<string, {
-    jde: string | null;
-    employee: import("./index.js").Employee | null;
-}>;
-export declare const verifyIdentity: import("@sveltejs/kit").RemoteCommand<{
-    first3FirstName: string;
-    first3LastName: string;
-    dob: string;
-    ssn4: string;
-}, Promise<import("./index.js").Employee | null>>;
+export declare const employees: {
+    getAll: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Employee[]>;
+    dropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
+    get: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee | null>;
+    getPrivileged: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").EmployeePrivileged>;
+    getSupervisorChain: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
+    getJdeFromEmail: import("@sveltejs/kit").RemoteQueryFunction<string, {
+        jde: string | null;
+        employee: import("./index.js").Employee | null;
+    }>;
+    verifyIdentity: import("@sveltejs/kit").RemoteCommand<{
+        first3FirstName: string;
+        first3LastName: string;
+        dob: string;
+        ssn4: string;
+    }, Promise<import("./index.js").Employee | null>>;
+};

package/dist/employees.remote.js

@@ -1,6 +1,21 @@
 import { query, command } from '$app/server';
 import { z } from 'zod';
 import { getClient } from './client.js';
+function isNotFoundError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /not found/i.test(error.message);
+}
+async function asNullable(fetcher) {
+    try {
+        return await fetcher();
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+}
 const employeeIdSchema = z.string().min(1);
 const verifyIdentitySchema = z.object({
     first3FirstName: z.string(),
@@ -8,10 +23,19 @@ const verifyIdentitySchema = z.object({
     dob: z.string(),
     ssn4: z.string(),
 });
-export const getEmployees = query(async () => getClient().getEmployees());
-export const getEmployeesDropdown = query(async () => getClient().getEmployeesDropdown());
-export const getEmployee = query(employeeIdSchema, async (employeeId) => getClient().getEmployee(employeeId));
-export const getEmployeePrivileged = query(employeeIdSchema, async (employeeId) => getClient().getEmployeePrivileged(employeeId));
-export const getSupervisorChain = query(employeeIdSchema, async (employeeId) => getClient().getSupervisorChain(employeeId));
-export const getJdeFromEmail = query(z.string(), async (email) => getClient().getJdeFromEmail(email));
-export const verifyIdentity = command(verifyIdentitySchema, async (inputs) => getClient().verifyIdentity(inputs));
+const getAll = query(async () => getClient().getEmployees());
+const dropdown = query(async () => getClient().getEmployeesDropdown());
+const get = query(employeeIdSchema, async (employeeId) => asNullable(() => getClient().getEmployee(employeeId)));
+const getPrivileged = query(employeeIdSchema, async (employeeId) => getClient().getEmployeePrivileged(employeeId));
+const getSupervisorChain = query(employeeIdSchema, async (employeeId) => getClient().getSupervisorChain(employeeId));
+const getJdeFromEmail = query(z.string(), async (email) => getClient().getJdeFromEmail(email));
+const verifyIdentity = command(verifyIdentitySchema, async (inputs) => getClient().verifyIdentity(inputs));
+export const employees = {
+    getAll,
+    dropdown,
+    get,
+    getPrivileged,
+    getSupervisorChain,
+    getJdeFromEmail,
+    verifyIdentity,
+};

package/dist/index.d.ts

@@ -57,6 +57,29 @@ export interface ApiHubClientOptions {
     apiKey: string;
     /** Default cache TTL in milliseconds. Set to 0 to disable caching. Default: 5 minutes. */
     cacheTtl?: number;
+    /** Request timeout in milliseconds. Default: 10000. */
+    timeoutMs?: number;
+    /** Retry count for idempotent GET requests on transient failures. Default: 2. */
+    retryCount?: number;
+    /** Optional hook invoked whenever an APIHubError is raised. */
+    onError?: (error: ApiHubError) => void;
+}
+export declare class ApiHubError extends Error {
+    status: number | null;
+    path: string;
+    url: string;
+    responseBody: unknown;
+    retriable: boolean;
+    service: string;
+    constructor(options: {
+        message: string;
+        status: number | null;
+        path: string;
+        url: string;
+        responseBody: unknown;
+        retriable: boolean;
+        service?: string;
+    });
 }
 export interface DropdownOption {
     value: number | string;
@@ -208,8 +231,15 @@ export declare class ApiHubClient {
     private baseUrl;
     private apiKey;
     private cacheTtl;
+    private timeoutMs;
+    private retryCount;
+    private onError?;
     private cache;
     constructor(options: ApiHubClientOptions);
+    private isRetriableStatus;
+    private createApiHubError;
+    private fetchWithTimeout;
+    private delay;
     /** Clear all cached responses, or a specific path */
     clearCache(path?: string): void;
     private cachedRequest;
@@ -288,3 +318,7 @@ export declare class ApiHubClient {
     getJobtypejobstepsDropdown(): Promise<DropdownOption[]>;
     getJobtypejobstep(id: string): Promise<Jobtypejobstep>;
 }
+export { employees, workorders, costcodes, paytypes, businessUnits, jobtypejobsteps, clearCache } from './cache.js';
+export { llm } from './llm.remote.js';
+export { rag } from './rag.remote.js';
+export type { EmployeeFilters, WorkorderFilters, CostcodeFilters, PaytypeFilters, BusinessUnitFilters, JobtypejobstepFilters, } from './cache.js';