lemma-sdk 0.2.30 → 0.2.31

package/dist/react/useCurrentUser.js

@@ -0,0 +1,68 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError } from "./utils.js";
+export function useCurrentUser({ client, enabled = true, autoLoad = true, }) {
+    const [user, setUser] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async (signal) => {
+        if (!enabled) {
+            setUser(null);
+            setError(null);
+            setIsLoading(false);
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const nextUser = await client.users.current();
+            if (signal?.aborted)
+                return null;
+            setUser(nextUser);
+            return nextUser;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return null;
+            const normalized = normalizeError(refreshError, "Failed to load current user.");
+            setError(normalized);
+            setUser(null);
+            return null;
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, enabled]);
+    useEffect(() => {
+        if (!enabled) {
+            setUser(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load current user."), "Failed to load current user."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
+    }, [autoLoad, enabled, refresh]);
+    return useMemo(() => ({
+        user,
+        isLoading,
+        error,
+        refresh,
+    }), [error, isLoading, refresh, user]);
+}

package/dist/react/useDeleteRecord.js

@@ -1,18 +1,13 @@
-import { useCallback, useMemo, useState } from "react";
-function resolvePodClient(client, podId) {
-    if (!podId || podId === client.podId)
-        return client;
-    return client.withPod(podId);
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
 export function useDeleteRecord({ client, podId, tableName, recordId = null, enabled = true, onSuccess, onError, }) {
     const [isSubmitting, setIsSubmitting] = useState(false);
     const [error, setError] = useState(null);
     const [lastMessage, setLastMessage] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
     const trimmedTableName = tableName.trim();
     const trimmedRecordId = typeof recordId === "string" ? recordId.trim() : "";
     const isEnabled = enabled && trimmedTableName.length > 0;
@@ -21,8 +16,6 @@ export function useDeleteRecord({ client, podId, tableName, recordId = null, ena
             ? overrides.recordId.trim()
             : trimmedRecordId;
         if (!isEnabled || nextRecordId.length === 0) {
-            const disabledError = new Error("Record deletion requires a table and record ID.");
-            setError(disabledError);
             return false;
         }
         setIsSubmitting(true);
@@ -31,19 +24,19 @@ export function useDeleteRecord({ client, podId, tableName, recordId = null, ena
             const scopedClient = resolvePodClient(client, podId);
             const response = await scopedClient.records.delete(trimmedTableName, nextRecordId);
             setLastMessage(response.message ?? "Record deleted.");
-            onSuccess?.(response);
+            onSuccessRef.current?.(response);
             return true;
         }
         catch (mutationError) {
             const normalized = normalizeError(mutationError, "Failed to delete record.");
             setError(normalized);
-            onError?.(mutationError);
+            onErrorRef.current?.(mutationError);
             return false;
         }
         finally {
             setIsSubmitting(false);
         }
-    }, [client, isEnabled, onError, onSuccess, podId, trimmedRecordId, trimmedTableName]);
+    }, [client, isEnabled, podId, trimmedRecordId, trimmedTableName]);
     const reset = useCallback(() => {
         setError(null);
         setIsSubmitting(false);

package/dist/react/useFlowRunHistory.js

@@ -1,9 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
+import { normalizeError } from "./utils.js";
 export function useFlowRunHistory({ session, flowName, limit = 100, autoRefresh = true, }) {
     const { listHistory, run: liveRun, runId: liveRunId, setRunId } = session;
     const [runs, setRuns] = useState([]);

package/dist/react/useFlowSession.js

@@ -1,12 +1,6 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { isTerminalFlowStatus, normalizeRunStatus, sleep } from "../run-utils.js";
-function resolvePodId(client, podId) {
-    const resolved = podId ?? client.podId;
-    if (!resolved) {
-        throw new Error("podId is required. Pass podId or set it on LemmaClient.");
-    }
-    return resolved;
-}
+import { normalizeError, resolvePodClient, resolvePodId } from "./utils.js";
 function resolveFlowName(base, override) {
     const resolved = override ?? base;
     if (!resolved) {
@@ -21,17 +15,16 @@ function resolveRunId(base, override) {
     }
     return resolved;
 }
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
 export function useFlowSession({ client, podId, flowName, runId: initialRunId = null, autoPoll = true, pollIntervalMs = 2000, onRun, onError, }) {
     const [runId, setRunIdState] = useState(initialRunId);
     const [run, setRun] = useState(null);
     const [status, setStatus] = useState(undefined);
     const [isPolling, setIsPolling] = useState(false);
     const [error, setError] = useState(null);
+    const onRunRef = useRef(onRun);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onRunRef.current = onRun; }, [onRun]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
     const setRunId = useCallback((nextRunId) => {
         setRunIdState(nextRunId);
         if (!nextRunId) {
@@ -49,21 +42,21 @@ export function useFlowSession({ client, podId, flowName, runId: initialRunId =
             setRun(nextRun);
             const nextStatus = normalizeRunStatus(nextRun.status);
             setStatus(nextStatus);
-            onRun?.(nextRun);
+            onRunRef.current?.(nextRun);
             return nextRun;
         }
         catch (refreshError) {
             const normalized = normalizeError(refreshError, "Failed to fetch flow run.");
             setError(normalized);
-            onError?.(refreshError);
+            onErrorRef.current?.(refreshError);
             return null;
         }
-    }, [client, onError, onRun, podId, runId]);
+    }, [client, podId, runId]);
     const listHistory = useCallback(async (options = {}) => {
         try {
-            client.setPodId(resolvePodId(client, podId));
+            const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
             const name = resolveFlowName(flowName, options.flowName);
-            const response = await client.workflows.runs.list(name, {
+            const response = await scopedClient.workflows.runs.list(name, {
                 limit: options.limit,
                 pageToken: options.pageToken,
             });
@@ -72,25 +65,25 @@ export function useFlowSession({ client, podId, flowName, runId: initialRunId =
         catch (listError) {
             const normalized = normalizeError(listError, "Failed to list flow runs.");
             setError(normalized);
-            onError?.(listError);
+            onErrorRef.current?.(listError);
             return [];
         }
-    }, [client, flowName, onError, podId]);
+    }, [client, flowName, podId]);
     const start = useCallback(async (options = {}) => {
         setError(null);
-        client.setPodId(resolvePodId(client, podId));
+        const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
         const name = resolveFlowName(flowName, options.flowName);
-        const created = await client.workflows.runs.start(name, options.inputs);
+        const created = await scopedClient.workflows.runs.start(name, options.inputs);
         setRun(created);
         setRunIdState(created.id ?? null);
         const nextStatus = normalizeRunStatus(created.status);
         setStatus(nextStatus);
-        onRun?.(created);
+        onRunRef.current?.(created);
         if (options.connect !== false && created.id) {
             await refresh(created.id);
         }
         return created;
-    }, [client, flowName, onRun, podId, refresh]);
+    }, [client, flowName, podId, refresh]);
     const resume = useCallback(async (options) => {
         setError(null);
         const resolvedPodId = resolvePodId(client, podId);
@@ -100,12 +93,12 @@ export function useFlowSession({ client, podId, flowName, runId: initialRunId =
         setRunIdState(resumed.id ?? id);
         const nextStatus = normalizeRunStatus(resumed.status);
         setStatus(nextStatus);
-        onRun?.(resumed);
+        onRunRef.current?.(resumed);
         if (options.connect !== false) {
             await refresh(resumed.id ?? id);
         }
         return resumed;
-    }, [client, onRun, podId, refresh, runId]);
+    }, [client, podId, refresh, runId]);
     const cancel = useCallback(async (explicitRunId) => {
         try {
             const resolvedPodId = resolvePodId(client, podId);
@@ -116,9 +109,9 @@ export function useFlowSession({ client, podId, flowName, runId: initialRunId =
         catch (cancelError) {
             const normalized = normalizeError(cancelError, "Failed to cancel flow run.");
             setError(normalized);
-            onError?.(cancelError);
+            onErrorRef.current?.(cancelError);
         }
-    }, [client, onError, podId, refresh, runId]);
+    }, [client, podId, refresh, runId]);
     const retry = useCallback(async (explicitRunId) => {
         try {
             const resolvedPodId = resolvePodId(client, podId);
@@ -129,14 +122,29 @@ export function useFlowSession({ client, podId, flowName, runId: initialRunId =
         catch (retryError) {
             const normalized = normalizeError(retryError, "Failed to retry flow run.");
             setError(normalized);
-            onError?.(retryError);
+            onErrorRef.current?.(retryError);
         }
-    }, [client, onError, podId, refresh, runId]);
+    }, [client, podId, refresh, runId]);
     useEffect(() => {
         if (!runId) {
             return;
         }
-        void refresh(runId);
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(runId);
+            }
+            catch {
+                if (!cancelled) {
+                    // refresh handles errors internally
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [refresh, runId]);
     useEffect(() => {
         if (!autoPoll || !runId) {
@@ -170,14 +178,14 @@ export function useFlowSession({ client, podId, flowName, runId: initialRunId =
         void loop().catch((pollError) => {
             const normalized = normalizeError(pollError, "Failed while polling flow run.");
             setError(normalized);
-            onError?.(pollError);
+            onErrorRef.current?.(pollError);
             setIsPolling(false);
         });
         return () => {
             active = false;
             abortController.abort();
         };
-    }, [autoPoll, onError, pollIntervalMs, refresh, runId]);
+    }, [autoPoll, pollIntervalMs, refresh, runId]);
     return {
         runId,
         run,

package/dist/react/useForeignKeyOptions.js

@@ -1,18 +1,7 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { parseForeignKeyReference } from "../datastore-query.js";
+import { normalizeError, resolvePodId } from "./utils.js";
 const EMPTY_LABEL_FIELDS = [];
-function resolvePodId(client, podId) {
-    const resolved = podId ?? client.podId;
-    if (!resolved) {
-        throw new Error("podId is required. Pass podId or set it on LemmaClient.");
-    }
-    return resolved;
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
 function readRecordValue(record, field) {
     if (!field)
         return undefined;
@@ -67,7 +56,7 @@ export function useForeignKeyOptions({ client, podId, tableName, columnName, lab
     const [error, setError] = useState(null);
     const labelFieldsKey = useMemo(() => JSON.stringify(labelFields), [labelFields]);
     const stableLabelFields = useMemo(() => labelFields, [labelFieldsKey]);
-    const refresh = useCallback(async () => {
+    const refresh = useCallback(async (signal) => {
         if (!enabled)
             return [];
         setIsLoading(true);
@@ -76,6 +65,8 @@ export function useForeignKeyOptions({ client, podId, tableName, columnName, lab
             const resolvedPodId = resolvePodId(client, podId);
             const scopedClient = resolvedPodId === client.podId ? client : client.withPod(resolvedPodId);
             const nextTable = await scopedClient.tables.get(tableName);
+            if (signal?.aborted)
+                return [];
             const nextColumn = nextTable.columns.find((entry) => entry.name === columnName) ?? null;
             const nextReference = nextColumn?.foreign_key?.references
                 ? parseForeignKeyReference(nextColumn.foreign_key.references)
@@ -98,6 +89,8 @@ export function useForeignKeyOptions({ client, podId, tableName, columnName, lab
                     ? [{ field: labelField, op: "ilike", value: `%${search?.trim()}%` }]
                     : undefined,
             });
+            if (signal?.aborted)
+                return [];
             const records = response.items ?? [];
             const nextResolvedLabelField = pickResolvedLabelField(records, nextReference.column, labelField, stableLabelFields);
             const searchableFields = Array.from(new Set([nextResolvedLabelField, ...stableLabelFields, nextReference.column, "id"]
@@ -124,18 +117,36 @@ export function useForeignKeyOptions({ client, podId, tableName, columnName, lab
             return nextOptions;
         }
         catch (refreshError) {
+            if (signal?.aborted)
+                return [];
             const normalized = normalizeError(refreshError, "Failed to load foreign key options.");
             setError(normalized);
             return [];
         }
         finally {
-            setIsLoading(false);
+            if (!signal?.aborted)
+                setIsLoading(false);
         }
     }, [client, columnName, enabled, labelField, limit, podId, search, stableLabelFields, tableName]);
     useEffect(() => {
         if (!enabled || !autoLoad)
             return;
-        void refresh();
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load foreign key options."), "Failed to load foreign key options."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
     }, [autoLoad, enabled, refresh]);
     return useMemo(() => ({
         table,

package/dist/react/useFunctionRun.d.ts

@@ -0,0 +1,19 @@
+import type { FunctionRun } from "../types.js";
+import { type UseFunctionSessionOptions, type UseFunctionSessionResult } from "./useFunctionSession.js";
+export interface UseFunctionRunOptions extends UseFunctionSessionOptions {
+}
+export interface UseFunctionRunResult extends Omit<UseFunctionSessionResult, "start" | "listHistory"> {
+    output: FunctionRun["output_data"];
+    finalOutput: FunctionRun["output_data"];
+    isFinished: boolean;
+    start: (input?: Record<string, unknown>, options?: {
+        functionName?: string;
+        connect?: boolean;
+    }) => Promise<FunctionRun>;
+    listRuns: (options?: {
+        functionName?: string;
+        limit?: number;
+        pageToken?: string;
+    }) => Promise<FunctionRun[]>;
+}
+export declare function useFunctionRun(options: UseFunctionRunOptions): UseFunctionRunResult;

package/dist/react/useFunctionRun.js

@@ -0,0 +1,30 @@
+import { useCallback, useMemo } from "react";
+import { isTerminalFunctionStatus, normalizeRunStatus } from "../run-utils.js";
+import { useFunctionSession, } from "./useFunctionSession.js";
+export function useFunctionRun(options) {
+    const session = useFunctionSession(options);
+    const start = useCallback(async (input, startOptions = {}) => {
+        return session.start({
+            functionName: startOptions.functionName,
+            input,
+            connect: startOptions.connect,
+        });
+    }, [session]);
+    const listRuns = useCallback(async (listOptions = {}) => {
+        return session.listHistory(listOptions);
+    }, [session]);
+    return useMemo(() => {
+        const normalizedStatus = normalizeRunStatus(session.status);
+        const isFinished = isTerminalFunctionStatus(normalizedStatus);
+        const output = session.run?.output_data ?? null;
+        const finalOutput = isFinished ? output : null;
+        return {
+            ...session,
+            output,
+            finalOutput,
+            isFinished,
+            start,
+            listRuns,
+        };
+    }, [listRuns, session, start]);
+}

package/dist/react/useFunctionRuns.d.ts

@@ -0,0 +1,33 @@
+import type { LemmaClient } from "../client.js";
+import type { FunctionRun } from "../types.js";
+export interface UseFunctionRunsOptions {
+    client: LemmaClient;
+    podId?: string;
+    functionName: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    limit?: number;
+    pageToken?: string;
+    initialRunId?: string | null;
+}
+export interface UseFunctionRunsResult {
+    runs: FunctionRun[];
+    total: number;
+    nextPageToken: string | null;
+    selectedRunId: string | null;
+    effectiveSelectedRunId: string | null;
+    selectedRun: FunctionRun | null;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    error: Error | null;
+    selectRun: (runId: string | null) => void;
+    clearSelection: () => void;
+    refresh: (overrides?: {
+        limit?: number;
+        pageToken?: string;
+    }) => Promise<FunctionRun[]>;
+    loadMore: (overrides?: {
+        limit?: number;
+    }) => Promise<FunctionRun[]>;
+}
+export declare function useFunctionRuns({ client, podId, functionName, enabled, autoLoad, limit, pageToken, initialRunId, }: UseFunctionRunsOptions): UseFunctionRunsResult;

package/dist/react/useFunctionRuns.js

@@ -0,0 +1,149 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useFunctionRuns({ client, podId, functionName, enabled = true, autoLoad = true, limit = 100, pageToken, initialRunId = null, }) {
+    const [runs, setRuns] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [nextPageToken, setNextPageToken] = useState(null);
+    const [selectedRunId, setSelectedRunId] = useState(initialRunId);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [error, setError] = useState(null);
+    const trimmedFunctionName = functionName.trim();
+    const isEnabled = enabled && trimmedFunctionName.length > 0;
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        if (!isEnabled) {
+            setRuns([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            return [];
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.functions.runs.list(trimmedFunctionName, {
+                limit: overrides.limit ?? limit,
+                pageToken: overrides.pageToken ?? pageToken,
+            });
+            if (signal?.aborted)
+                return [];
+            const nextRuns = response.items ?? [];
+            setRuns(nextRuns);
+            setTotal(response.total ?? nextRuns.length);
+            setNextPageToken(response.next_page_token ?? null);
+            setSelectedRunId((current) => (current && nextRuns.some((run) => run.id === current) ? current : initialRunId));
+            return nextRuns;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return [];
+            const normalized = normalizeError(refreshError, "Failed to load function runs.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, initialRunId, isEnabled, limit, pageToken, podId, trimmedFunctionName]);
+    const loadMore = useCallback(async (overrides = {}) => {
+        if (!isEnabled || !nextPageToken || isLoading || isLoadingMore) {
+            return [];
+        }
+        setIsLoadingMore(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.functions.runs.list(trimmedFunctionName, {
+                limit: overrides.limit ?? limit,
+                pageToken: nextPageToken,
+            });
+            const moreRuns = response.items ?? [];
+            setRuns((previous) => [...previous, ...moreRuns]);
+            setTotal(response.total ?? runs.length + moreRuns.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreRuns;
+        }
+        catch (loadError) {
+            const normalized = normalizeError(loadError, "Failed to load more function runs.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, podId, trimmedFunctionName]);
+    useEffect(() => {
+        setSelectedRunId(initialRunId);
+    }, [initialRunId]);
+    useEffect(() => {
+        if (!isEnabled) {
+            setRuns([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            setIsLoadingMore(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh({}, controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load function runs."), "Failed to load function runs."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
+    }, [autoLoad, isEnabled, refresh]);
+    const selectRun = useCallback((runId) => {
+        setSelectedRunId(runId);
+    }, []);
+    const clearSelection = useCallback(() => {
+        setSelectedRunId(null);
+    }, []);
+    return useMemo(() => {
+        const effectiveSelectedRunId = selectedRunId ?? runs[0]?.id ?? null;
+        const selectedRun = effectiveSelectedRunId
+            ? runs.find((run) => run.id === effectiveSelectedRunId) ?? null
+            : null;
+        return {
+            runs,
+            total,
+            nextPageToken,
+            selectedRunId,
+            effectiveSelectedRunId,
+            selectedRun,
+            isLoading,
+            isLoadingMore,
+            error,
+            selectRun,
+            clearSelection,
+            refresh,
+            loadMore,
+        };
+    }, [
+        clearSelection,
+        error,
+        isLoading,
+        isLoadingMore,
+        loadMore,
+        nextPageToken,
+        refresh,
+        runs,
+        selectRun,
+        selectedRunId,
+        total,
+    ]);
+}