@brownandroot/api 1.0.0 → 1.2.0

package/dist/cache.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Client-side cache API for @brownandroot/api.
+ *
+ * Wraps remote functions with an IndexedDB stale-while-revalidate cache so
+ * pages load instantly on subsequent visits. Filters are applied in-memory
+ * against the full cached dataset — no per-field server endpoints needed.
+ *
+ * Import from: @brownandroot/api/cache
+ */
+import type { Employee, EmployeePrivileged, BusinessUnit, Costcode, Paytype, Workorder, Jobtypejobstep, DropdownOption, PaytypeDropdownOption } from './index.js';
+import { type IdbStore } from './idb.js';
+export interface EmployeeFilters {
+    /** Exact match on businessUnitId */
+    businessUnitId?: string;
+    /** Exact match on home business unit (hbu) */
+    hbu?: string;
+    /** Exact match on supervisor employee ID */
+    supervisor?: string;
+    /** Exact match on payClass */
+    payClass?: string;
+    /** Exact match on jobType */
+    jobType?: string;
+    /** Exact match on jobStep */
+    jobStep?: string;
+    /** Exact match on sector */
+    sector?: string;
+    /** Exact match on division */
+    division?: string;
+    /** Case-insensitive partial match on name or email */
+    q?: string;
+}
+export interface WorkorderFilters {
+    /** Exact match on businessUnitId */
+    businessUnitId?: string;
+    /** Exact match on costCodeId */
+    costCodeId?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on completed */
+    completed?: boolean;
+    /** Exact match on area */
+    area?: string;
+    /** Exact match on parentWorkOrder */
+    parentWorkOrder?: string;
+    /** Case-insensitive partial match on description or clientWorkOrderId */
+    q?: string;
+}
+export interface CostcodeFilters {
+    /** Exact match on businessUnitId */
+    businessUnitId?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on entryFlag */
+    entryFlag?: boolean;
+    /**
+     * Filter by pay type — resolves the pay type's objectAccount and returns
+     * only cost codes whose objectAccount matches. If the pay type has no
+     * objectAccount, all cost codes pass this filter.
+     */
+    payTypeCode?: string;
+    /** Case-insensitive partial match on description or jdeCostCode */
+    q?: string;
+}
+export interface PaytypeFilters {
+    /** Exact match on payClass */
+    payClass?: string;
+    /** Exact match on category */
+    category?: string;
+    /** Exact match on type */
+    type?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on perDiemPayType */
+    perDiemPayType?: boolean;
+    /** Case-insensitive partial match on description */
+    q?: string;
+}
+export interface BusinessUnitFilters {
+    /** Exact match on subsector */
+    subsector?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on clientId */
+    clientId?: string;
+    /** Case-insensitive partial match on description or clientDescription */
+    q?: string;
+}
+export interface JobtypejobstepFilters {
+    /** Exact match on jobType */
+    jobType?: string;
+    /** Exact match on payclass */
+    payclass?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on grp */
+    grp?: string;
+    /** 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>;
+/** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
+export declare function getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
+/** Full supervisor chain above an employee — always fetches fresh. */
+export 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<{
+    jde: string | null;
+    employee: Employee | null;
+}>;
+/** Verify employee identity — always fetches fresh. */
+export 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>;
+/**
+ * Clear the IndexedDB cache for a specific entity, or all entities.
+ *
+ * Call after mutations to ensure the next read fetches fresh data from
+ * the server instead of returning stale cached results.
+ *
+ * @example
+ * await createWorkorder(data)
+ * clearCache('workorders')  // next getWorkorders() will re-fetch
+ *
+ * clearCache()  // clear everything
+ */
+export declare function clearCache(entity?: IdbStore): void;

package/dist/cache.js

@@ -0,0 +1,324 @@
+/**
+ * Client-side cache API for @brownandroot/api.
+ *
+ * Wraps remote functions with an IndexedDB stale-while-revalidate cache so
+ * pages load instantly on subsequent visits. Filters are applied in-memory
+ * against the full cached dataset — no per-field server endpoints needed.
+ *
+ * Import from: @brownandroot/api/cache
+ */
+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';
+// ---------------------------------------------------------------------------
+// Internal: stale-while-revalidate fetch helpers
+// ---------------------------------------------------------------------------
+async function loadCached(store, fetcher) {
+    const cached = await idbGet(store, 'all');
+    if (cached) {
+        // Return stale data immediately; refresh in background for next call
+        fetcher()
+            .then((fresh) => idbSet(store, 'all', fresh))
+            .catch(() => { });
+        return cached.data;
+    }
+    // Cache miss — must await
+    const data = await fetcher();
+    await idbSet(store, 'all', data);
+    return data;
+}
+// ---------------------------------------------------------------------------
+// Internal: filter helpers
+// ---------------------------------------------------------------------------
+function applyEmployeeFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((e) => {
+        if (f.businessUnitId !== undefined && e.businessUnitId !== f.businessUnitId)
+            return false;
+        if (f.hbu !== undefined && e.hbu !== f.hbu)
+            return false;
+        if (f.supervisor !== undefined && e.supervisor !== f.supervisor)
+            return false;
+        if (f.payClass !== undefined && e.payClass !== f.payClass)
+            return false;
+        if (f.jobType !== undefined && e.jobType !== f.jobType)
+            return false;
+        if (f.jobStep !== undefined && e.jobStep !== f.jobStep)
+            return false;
+        if (f.sector !== undefined && e.sector !== f.sector)
+            return false;
+        if (f.division !== undefined && e.division !== f.division)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const name = e.name?.toLowerCase() ?? '';
+            const email = e.email?.toLowerCase() ?? '';
+            if (!name.includes(q) && !email.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyWorkorderFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((w) => {
+        if (f.businessUnitId !== undefined && w.businessUnitId !== f.businessUnitId)
+            return false;
+        if (f.costCodeId !== undefined && w.costCodeId !== f.costCodeId)
+            return false;
+        if (f.isActive !== undefined && w.isActive !== f.isActive)
+            return false;
+        if (f.completed !== undefined && w.completed !== f.completed)
+            return false;
+        if (f.area !== undefined && w.area !== f.area)
+            return false;
+        if (f.parentWorkOrder !== undefined && w.parentWorkOrder !== f.parentWorkOrder)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = w.description?.toLowerCase() ?? '';
+            const wo = w.clientWorkOrderId?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !wo.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyPaytypeFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((p) => {
+        if (f.payClass !== undefined && p.payClass !== f.payClass)
+            return false;
+        if (f.category !== undefined && p.category !== f.category)
+            return false;
+        if (f.type !== undefined && p.type !== f.type)
+            return false;
+        if (f.isActive !== undefined && p.isActive !== f.isActive)
+            return false;
+        if (f.perDiemPayType !== undefined && p.perDiemPayType !== f.perDiemPayType)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            if (!p.description.toLowerCase().includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyBusinessUnitFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((b) => {
+        if (f.subsector !== undefined && b.subsector !== f.subsector)
+            return false;
+        if (f.isActive !== undefined && b.isActive !== f.isActive)
+            return false;
+        if (f.clientId !== undefined && b.clientId !== f.clientId)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = b.description.toLowerCase();
+            const client = b.clientDescription?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !client.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyJobtypejobstepFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((j) => {
+        if (f.jobType !== undefined && j.jobType !== f.jobType)
+            return false;
+        if (f.payclass !== undefined && j.payclass !== f.payclass)
+            return false;
+        if (f.isActive !== undefined && j.isActive !== f.isActive)
+            return false;
+        if (f.grp !== undefined && j.grp !== f.grp)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = j.description?.toLowerCase() ?? '';
+            const jt = j.jobType?.toLowerCase() ?? '';
+            const js = j.jobStep?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !jt.includes(q) && !js.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+// Costcodes filter is async because payTypeCode requires a cross-reference
+async function applyCostcodeFilters(data, f) {
+    if (!f)
+        return data;
+    // Resolve payTypeCode → objectAccount
+    let payTypeObjectAccount;
+    if (f.payTypeCode !== undefined) {
+        const allPaytypes = await loadCached('paytypes', () => _getPaytypes());
+        payTypeObjectAccount = allPaytypes.find((p) => p.id === f.payTypeCode)?.objectAccount;
+    }
+    return data.filter((c) => {
+        if (f.businessUnitId !== undefined && c.businessUnitId !== f.businessUnitId)
+            return false;
+        if (f.isActive !== undefined && c.isActive !== f.isActive)
+            return false;
+        if (f.entryFlag !== undefined && c.entryFlag !== f.entryFlag)
+            return false;
+        if (f.payTypeCode !== undefined) {
+            // If paytype has an objectAccount, cost code must match it
+            if (payTypeObjectAccount && c.objectAccount !== payTypeObjectAccount)
+                return false;
+        }
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = c.description?.toLowerCase() ?? '';
+            const code = c.jdeCostCode?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !code.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+// ---------------------------------------------------------------------------
+// Public API — Employees
+// ---------------------------------------------------------------------------
+export async function getEmployees(filters) {
+    const all = await loadCached('employees', () => _getEmployees());
+    return applyEmployeeFilters(all, filters);
+}
+export 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);
+}
+/** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
+export async function getEmployeePrivileged(employeeId) {
+    return _getEmployeePrivileged(employeeId);
+}
+/** Full supervisor chain above an employee — always fetches fresh. */
+export async function getSupervisorChain(employeeId) {
+    return _getSupervisorChain(employeeId);
+}
+/** Look up JDE number and employee from email — always fetches fresh. */
+export async function getJdeFromEmail(email) {
+    return _getJdeFromEmail(email);
+}
+/** Verify employee identity — always fetches fresh. */
+export async function verifyIdentity(inputs) {
+    return _verifyIdentity(inputs);
+}
+// ---------------------------------------------------------------------------
+// Public API — Workorders
+// ---------------------------------------------------------------------------
+export async function getWorkorders(filters) {
+    const all = await loadCached('workorders', () => _getWorkorders());
+    return applyWorkorderFilters(all, filters);
+}
+export 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);
+}
+// ---------------------------------------------------------------------------
+// Public API — Cost Codes
+// ---------------------------------------------------------------------------
+export async function getCostcodes(filters) {
+    const all = await loadCached('costcodes', () => _getCostcodes());
+    return applyCostcodeFilters(all, filters);
+}
+export async function getCostcodesDropdown(filters) {
+    const mergedFilters = { isActive: true, entryFlag: true, ...filters };
+    const results = await getCostcodes(mergedFilters);
+    const now = new Date();
+    return results
+        .filter((c) => !c.expirationDate || new Date(c.expirationDate) >= now)
+        .map((c) => ({
+        value: c.id,
+        label: `${c.jdeCostCode ?? c.id} - ${c.description ?? ''}`,
+    }));
+}
+/** Single cost code by ID — always fetches fresh (no IndexedDB). */
+export async function getCostcode(id) {
+    return _getCostcode(id);
+}
+// ---------------------------------------------------------------------------
+// Public API — Pay Types
+// ---------------------------------------------------------------------------
+export async function getPaytypes(filters) {
+    const all = await loadCached('paytypes', () => _getPaytypes());
+    return applyPaytypeFilters(all, filters);
+}
+export async function getPaytypesDropdown(filters) {
+    const results = await getPaytypes(filters);
+    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);
+}
+// ---------------------------------------------------------------------------
+// Public API — Business Units
+// ---------------------------------------------------------------------------
+export async function getBusinessUnits(filters) {
+    const all = await loadCached('businessUnits', () => _getBusinessUnits());
+    return applyBusinessUnitFilters(all, filters);
+}
+export async function getBusinessUnitsDropdown(filters) {
+    const results = await getBusinessUnits(filters);
+    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);
+}
+// ---------------------------------------------------------------------------
+// Public API — Job Type / Job Steps
+// ---------------------------------------------------------------------------
+export async function getJobtypejobsteps(filters) {
+    const all = await loadCached('jobtypejobsteps', () => _getJobtypejobsteps());
+    return applyJobtypejobstepFilters(all, filters);
+}
+export async function getJobtypejobstepsDropdown(filters) {
+    const results = await getJobtypejobsteps(filters);
+    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);
+}
+// ---------------------------------------------------------------------------
+// Cache management
+// ---------------------------------------------------------------------------
+/**
+ * Clear the IndexedDB cache for a specific entity, or all entities.
+ *
+ * Call after mutations to ensure the next read fetches fresh data from
+ * the server instead of returning stale cached results.
+ *
+ * @example
+ * await createWorkorder(data)
+ * clearCache('workorders')  // next getWorkorders() will re-fetch
+ *
+ * clearCache()  // clear everything
+ */
+export function clearCache(entity) {
+    idbClear(entity).catch(() => { });
+}

package/dist/costcodes.remote.d.ts

@@ -1,6 +1,3 @@
-export declare const getCostcodes: any;
-export declare const getCostcodesDropdown: any;
-export declare const getCostcode: any;
-export declare const getCostcodesDropdownByBu: any;
-export declare const getCostcodesDropdownByBuAndPayType: any;
-export declare const searchCostcodes: any;
+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>;

package/dist/costcodes.remote.js

@@ -1,13 +1,6 @@
 import { query } from '$app/server';
 import { z } from 'zod';
 import { getClient } from './client.js';
-const buPayTypeSchema = z.object({
-    businessUnitId: z.string(),
-    payTypeCode: z.string(),
-});
 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));
-export const getCostcodesDropdownByBu = query(z.string(), async (businessUnitId) => getClient().getCostcodesDropdownByBu(businessUnitId));
-export const getCostcodesDropdownByBuAndPayType = query(buPayTypeSchema, async ({ businessUnitId, payTypeCode }) => getClient().getCostcodesDropdownByBuAndPayType(businessUnitId, payTypeCode));
-export const searchCostcodes = query(z.string(), async (q) => getClient().searchCostcodes(q));

package/dist/employees.remote.d.ts

@@ -1,10 +1,15 @@
-export declare const getEmployees: any;
-export declare const getEmployeesDropdown: any;
-export declare const getEmployee: any;
-export declare const searchByName: any;
-export declare const getBySupervisor: any;
-export declare const searchByEmail: any;
-export declare const getSupervisorChain: any;
-export declare const getJdeFromEmail: any;
-export declare const searchByHbu: any;
-export declare const verifyIdentity: any;
+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>>;

package/dist/employees.remote.js

@@ -11,10 +11,7 @@ const verifyIdentitySchema = z.object({
 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 searchByName = query(z.string(), async (name) => getClient().searchByName(name));
-export const getBySupervisor = query(employeeIdSchema, async (supervisorId) => getClient().getBySupervisor(supervisorId));
-export const searchByEmail = query(z.string(), async (email) => getClient().searchByEmail(email));
+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 searchByHbu = query(z.string(), async (hbu) => getClient().searchByHbu(hbu));
 export const verifyIdentity = command(verifyIdentitySchema, async (inputs) => getClient().verifyIdentity(inputs));

package/dist/idb.d.ts

@@ -0,0 +1,13 @@
+declare const STORES: readonly ["workorders", "employees", "costcodes", "paytypes", "businessUnits", "jobtypejobsteps"];
+export type IdbStore = (typeof STORES)[number];
+interface IdbEntry<T> {
+    data: T;
+    fetchedAt: number;
+}
+/** Get a cached entry. Returns null in SSR (no window) or on cache miss. */
+export declare function idbGet<T>(store: IdbStore, key: string): Promise<IdbEntry<T> | null>;
+/** Store a value with the current timestamp. */
+export declare function idbSet<T>(store: IdbStore, key: string, data: T): Promise<void>;
+/** Clear a specific store, or all stores when called with no argument. */
+export declare function idbClear(store?: IdbStore): Promise<void>;
+export {};

package/dist/idb.js

@@ -0,0 +1,79 @@
+const DB_NAME = 'apihub-cache';
+const DB_VERSION = 1;
+const STORES = [
+    'workorders',
+    'employees',
+    'costcodes',
+    'paytypes',
+    'businessUnits',
+    'jobtypejobsteps',
+];
+function openDb() {
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(DB_NAME, DB_VERSION);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            for (const store of STORES) {
+                if (!db.objectStoreNames.contains(store)) {
+                    db.createObjectStore(store);
+                }
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+/** Get a cached entry. Returns null in SSR (no window) or on cache miss. */
+export async function idbGet(store, key) {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const db = await openDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(store, 'readonly');
+            const req = tx.objectStore(store).get(key);
+            req.onsuccess = () => resolve(req.result ?? null);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/** Store a value with the current timestamp. */
+export async function idbSet(store, key, data) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const db = await openDb();
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction(store, 'readwrite');
+            const req = tx.objectStore(store).put({ data, fetchedAt: Date.now() }, key);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    catch {
+        // Ignore write failures — cache is best-effort
+    }
+}
+/** Clear a specific store, or all stores when called with no argument. */
+export async function idbClear(store) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const db = await openDb();
+        const storeNames = store ? [store] : [...STORES];
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction(storeNames, 'readwrite');
+            for (const s of storeNames) {
+                tx.objectStore(s).clear();
+            }
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    catch {
+        // Ignore failures
+    }
+}

package/dist/index.d.ts

@@ -5,6 +5,9 @@ export interface Employee {
     employeeId: string;
     name: string | null;
     email: string | null;
+    personalEmail: string | null;
+    clientEmail: string | null;
+    workEmail: string | null;
     badgeNumber: string | null;
     employementStatus: string | null;
     residentTaxArea: string | null;
@@ -21,8 +24,6 @@ export interface Employee {
     jobDescription: string | null;
     workSchedule: string | null;
     shift: string | null;
-    hourlyRate: string | null;
-    annualSalary: string | null;
     termDate: string | null;
     hireDate: string | null;
     topFlexPtoDate: string | null;
@@ -47,6 +48,10 @@ export interface Employee {
     updatedAtJulian: number | null;
     updatedAt: string | null;
 }
+export interface EmployeePrivileged extends Employee {
+    hourlyRate: string | null;
+    annualSalary: string | null;
+}
 export interface ApiHubClientOptions {
     baseUrl: string;
     apiKey: string;
@@ -215,6 +220,8 @@ export declare class ApiHubClient {
     getEmployeesDropdown(): Promise<DropdownOption[]>;
     /** Get a single employee by employeeId */
     getEmployee(employeeId: string): Promise<Employee>;
+    /** Get a single employee with compensation fields by employeeId */
+    getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
     /** Search employees by name (case-insensitive partial match) */
     searchByName(name: string): Promise<Employee[]>;
     /** Get all employees reporting to a supervisor */