lemma-sdk 0.2.33 → 0.2.35

package/dist/react/useRecordAggregates.js

@@ -0,0 +1,126 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { encodeSqlValue, quoteIdentifierPath, renderIdentifierPath, renderRecordFilters } from "./sql-utils.js";
+import { normalizeError, resolvePodClient, stringifyComparable } from "./utils.js";
+function buildMetricExpression(metric) {
+    const fn = metric.op.toUpperCase();
+    if (metric.op === "count" && !metric.field) {
+        return `${fn}(*) AS ${quoteIdentifierPath(metric.key)}`;
+    }
+    if (!metric.field) {
+        throw new Error(`Aggregate metric "${metric.key}" requires a field.`);
+    }
+    const renderedField = renderIdentifierPath(metric.field);
+    const distinct = metric.distinct ? "DISTINCT " : "";
+    return `${fn}(${distinct}${renderedField}) AS ${quoteIdentifierPath(metric.key)}`;
+}
+function buildRecordAggregatesQuery({ tableName, metrics, groupBy, filters, limit, offset, orderBy, }) {
+    const groups = (Array.isArray(groupBy) ? groupBy : groupBy ? [groupBy] : [])
+        .map((field) => field.trim())
+        .filter((field) => field.length > 0);
+    const selectParts = [
+        ...groups.map((field) => `${renderIdentifierPath(field)} AS ${quoteIdentifierPath(field)}`),
+        ...metrics.map((metric) => buildMetricExpression(metric)),
+    ];
+    const whereClause = renderRecordFilters(filters);
+    const orderClause = orderBy?.length
+        ? ` ORDER BY ${orderBy.map((entry) => `${renderIdentifierPath(entry.field)} ${(entry.direction ?? "desc").toUpperCase()}`).join(", ")}`
+        : "";
+    const groupClause = groups.length
+        ? ` GROUP BY ${groups.map((field) => renderIdentifierPath(field)).join(", ")}`
+        : "";
+    const limitClause = typeof limit === "number" ? ` LIMIT ${encodeSqlValue(limit)}` : "";
+    const offsetClause = typeof offset === "number" ? ` OFFSET ${encodeSqlValue(offset)}` : "";
+    return [
+        `SELECT ${selectParts.join(", ")}`,
+        `FROM ${quoteIdentifierPath(tableName)}`,
+        whereClause ? `WHERE ${whereClause}` : "",
+        groupClause,
+        orderClause,
+        limitClause,
+        offsetClause,
+    ].filter(Boolean).join(" ");
+}
+export function useRecordAggregates({ client, podId, tableName, metrics, groupBy, filters = [], limit, offset, orderBy, enabled = true, autoLoad = true, }) {
+    const [rows, setRows] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [sql, setSql] = useState("");
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const metricsKey = stringifyComparable(metrics);
+    const filtersKey = stringifyComparable(filters);
+    const groupByKey = stringifyComparable(groupBy);
+    const orderByKey = stringifyComparable(orderBy);
+    const stableMetrics = useMemo(() => metrics, [metricsKey]);
+    const stableFilters = useMemo(() => filters, [filtersKey]);
+    const stableGroupBy = useMemo(() => groupBy, [groupByKey]);
+    const stableOrderBy = useMemo(() => orderBy, [orderByKey]);
+    const trimmedTableName = tableName.trim();
+    const isEnabled = enabled && trimmedTableName.length > 0 && stableMetrics.length > 0;
+    const refresh = useCallback(async (signal) => {
+        if (!isEnabled) {
+            setRows([]);
+            setTotal(0);
+            setSql("");
+            setError(null);
+            setIsLoading(false);
+            return [];
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextSql = buildRecordAggregatesQuery({
+                tableName: trimmedTableName,
+                metrics: stableMetrics,
+                groupBy: stableGroupBy,
+                filters: stableFilters,
+                limit,
+                offset,
+                orderBy: stableOrderBy,
+            });
+            setSql(nextSql);
+            const response = await scopedClient.datastore.query(nextSql);
+            if (signal?.aborted)
+                return [];
+            const nextRows = (response.items ?? []);
+            setRows(nextRows);
+            setTotal(response.total ?? nextRows.length);
+            return nextRows;
+        }
+        catch (aggregateError) {
+            if (signal?.aborted)
+                return [];
+            const normalized = normalizeError(aggregateError, "Failed to load record aggregates.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, isEnabled, limit, offset, podId, stableFilters, stableGroupBy, stableMetrics, stableOrderBy, trimmedTableName]);
+    useEffect(() => {
+        if (!isEnabled) {
+            setRows([]);
+            setTotal(0);
+            setSql("");
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        void refresh(controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, isEnabled, refresh]);
+    return useMemo(() => ({
+        rows,
+        row: rows[0] ?? null,
+        total,
+        sql,
+        isLoading,
+        error,
+        refresh,
+    }), [error, isLoading, refresh, rows, sql, total]);
+}

package/dist/react/useRemovePodMember.d.ts

@@ -0,0 +1,19 @@
+import type { LemmaClient } from "../client.js";
+export interface UseRemovePodMemberOptions {
+    client: LemmaClient;
+    podId?: string;
+    memberId?: string | null;
+    enabled?: boolean;
+    onSuccess?: (memberId: string) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseRemovePodMemberResult {
+    removedMemberId: string | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    remove: (overrides?: {
+        memberId?: string | null;
+    }) => Promise<boolean>;
+    reset: () => void;
+}
+export declare function useRemovePodMember({ client, podId, memberId, enabled, onSuccess, onError, }: UseRemovePodMemberOptions): UseRemovePodMemberResult;

package/dist/react/useRemovePodMember.js

@@ -0,0 +1,50 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodId } from "./utils.js";
+export function useRemovePodMember({ client, podId, memberId = null, enabled = true, onSuccess, onError, }) {
+    const [removedMemberId, setRemovedMemberId] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedMemberId = typeof memberId === "string" ? memberId.trim() : "";
+    const remove = useCallback(async (overrides = {}) => {
+        const nextMemberId = typeof overrides.memberId === "string"
+            ? overrides.memberId.trim()
+            : trimmedMemberId;
+        if (!enabled || nextMemberId.length === 0) {
+            return false;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const resolvedPodId = resolvePodId(client, podId);
+            await client.podMembers.remove(resolvedPodId, nextMemberId);
+            setRemovedMemberId(nextMemberId);
+            onSuccessRef.current?.(nextMemberId);
+            return true;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, "Failed to remove pod member.");
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return false;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId, trimmedMemberId]);
+    const reset = useCallback(() => {
+        setRemovedMemberId(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        removedMemberId,
+        isSubmitting,
+        error,
+        remove,
+        reset,
+    }), [error, isSubmitting, remove, removedMemberId, reset]);
+}

package/dist/react/useTaskSession.js

@@ -30,12 +30,13 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
         }
     }, []);
     const setTaskId = useCallback((nextTaskId) => {
-        abortRef.current?.abort();
-        abortRef.current = null;
         setTaskIdState((currentTaskId) => {
             if (currentTaskId === nextTaskId) {
                 return currentTaskId;
             }
+            abortRef.current?.abort();
+            abortRef.current = null;
+            taskIdRef.current = nextTaskId;
             setError(null);
             setIsStreaming(false);
             if (!nextTaskId) {

package/dist/react/useUpdateFile.d.ts

@@ -0,0 +1,29 @@
+import type { LemmaClient } from "../client.js";
+import type { FileResponse } from "../types.js";
+export interface UpdateFileInput {
+    file?: Blob;
+    name?: string;
+    description?: string;
+    directoryPath?: string;
+    parentId?: string;
+    newPath?: string;
+    searchEnabled?: boolean;
+}
+export interface UseUpdateFileOptions {
+    client: LemmaClient;
+    podId?: string;
+    path?: string | null;
+    enabled?: boolean;
+    onSuccess?: (file: FileResponse) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseUpdateFileResult<TFile extends FileResponse = FileResponse> {
+    updatedFile: TFile | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    update: (input?: UpdateFileInput, overrides?: {
+        path?: string | null;
+    }) => Promise<TFile | null>;
+    reset: () => void;
+}
+export declare function useUpdateFile<TFile extends FileResponse = FileResponse>({ client, podId, path, enabled, onSuccess, onError, }: UseUpdateFileOptions): UseUpdateFileResult<TFile>;

package/dist/react/useUpdateFile.js

@@ -0,0 +1,51 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useUpdateFile({ client, podId, path = null, enabled = true, onSuccess, onError, }) {
+    const [updatedFile, setUpdatedFile] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedPath = typeof path === "string" ? path.trim() : "";
+    const isEnabled = enabled && trimmedPath.length > 0;
+    const update = useCallback(async (input = {}, overrides = {}) => {
+        const nextPath = typeof overrides.path === "string"
+            ? overrides.path.trim()
+            : trimmedPath;
+        if (!isEnabled || nextPath.length === 0) {
+            return null;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextFile = await scopedClient.files.update(nextPath, input);
+            setUpdatedFile(nextFile);
+            onSuccessRef.current?.(nextFile);
+            return nextFile;
+        }
+        catch (updateError) {
+            const normalized = normalizeError(updateError, "Failed to update file.");
+            setError(normalized);
+            onErrorRef.current?.(updateError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, isEnabled, podId, trimmedPath]);
+    const reset = useCallback(() => {
+        setUpdatedFile(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        updatedFile,
+        isSubmitting,
+        error,
+        update,
+        reset,
+    }), [error, isSubmitting, reset, update, updatedFile]);
+}

package/dist/react/useUpdatePodMemberRole.d.ts

@@ -0,0 +1,20 @@
+import type { LemmaClient } from "../client.js";
+import type { PodMember, PodRole } from "../types.js";
+export interface UseUpdatePodMemberRoleOptions {
+    client: LemmaClient;
+    podId?: string;
+    memberId?: string | null;
+    enabled?: boolean;
+    onSuccess?: (member: PodMember) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseUpdatePodMemberRoleResult {
+    updatedMember: PodMember | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    updateRole: (role: PodRole, overrides?: {
+        memberId?: string | null;
+    }) => Promise<PodMember | null>;
+    reset: () => void;
+}
+export declare function useUpdatePodMemberRole({ client, podId, memberId, enabled, onSuccess, onError, }: UseUpdatePodMemberRoleOptions): UseUpdatePodMemberRoleResult;

package/dist/react/useUpdatePodMemberRole.js

@@ -0,0 +1,50 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodId } from "./utils.js";
+export function useUpdatePodMemberRole({ client, podId, memberId = null, enabled = true, onSuccess, onError, }) {
+    const [updatedMember, setUpdatedMember] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedMemberId = typeof memberId === "string" ? memberId.trim() : "";
+    const updateRole = useCallback(async (role, overrides = {}) => {
+        const nextMemberId = typeof overrides.memberId === "string"
+            ? overrides.memberId.trim()
+            : trimmedMemberId;
+        if (!enabled || nextMemberId.length === 0) {
+            return null;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const resolvedPodId = resolvePodId(client, podId);
+            const nextMember = await client.podMembers.updateRole(resolvedPodId, nextMemberId, role);
+            setUpdatedMember(nextMember);
+            onSuccessRef.current?.(nextMember);
+            return nextMember;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, "Failed to update pod member role.");
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId, trimmedMemberId]);
+    const reset = useCallback(() => {
+        setUpdatedMember(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        updatedMember,
+        isSubmitting,
+        error,
+        updateRole,
+        reset,
+    }), [error, isSubmitting, reset, updateRole, updatedMember]);
+}

package/dist/react/useUploadFile.d.ts

@@ -0,0 +1,24 @@
+import type { LemmaClient } from "../client.js";
+import type { FileResponse } from "../types.js";
+export interface UploadFileInput {
+    name?: string;
+    directoryPath?: string;
+    parentId?: string;
+    searchEnabled?: boolean;
+    description?: string;
+}
+export interface UseUploadFileOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    onSuccess?: (file: FileResponse) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseUploadFileResult<TFile extends FileResponse = FileResponse> {
+    uploadedFile: TFile | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    upload: (file: Blob, options?: UploadFileInput) => Promise<TFile | null>;
+    reset: () => void;
+}
+export declare function useUploadFile<TFile extends FileResponse = FileResponse>({ client, podId, enabled, onSuccess, onError, }: UseUploadFileOptions): UseUploadFileResult<TFile>;

package/dist/react/useUploadFile.js

@@ -0,0 +1,46 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useUploadFile({ client, podId, enabled = true, onSuccess, onError, }) {
+    const [uploadedFile, setUploadedFile] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const upload = useCallback(async (file, options = {}) => {
+        if (!enabled) {
+            return null;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextFile = await scopedClient.files.upload(file, options);
+            setUploadedFile(nextFile);
+            onSuccessRef.current?.(nextFile);
+            return nextFile;
+        }
+        catch (uploadError) {
+            const normalized = normalizeError(uploadError, "Failed to upload file.");
+            setError(normalized);
+            onErrorRef.current?.(uploadError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId]);
+    const reset = useCallback(() => {
+        setUploadedFile(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        uploadedFile,
+        isSubmitting,
+        error,
+        upload,
+        reset,
+    }), [error, isSubmitting, reset, uploadedFile, upload]);
+}

package/dist/react/useWorkflowStart.d.ts

@@ -1,5 +1,5 @@
 import type { LemmaClient } from "../client.js";
-import type { FlowRun, FlowStartType, Workflow, WorkflowRunInputs } from "../types.js";
+import type { FlowRun, Workflow, WorkflowStartType, WorkflowRunInputs } from "../types.js";
 import { type UseFlowSessionResult } from "./useFlowSession.js";
 export interface UseWorkflowStartOptions {
     client: LemmaClient;
@@ -15,7 +15,7 @@ export interface UseWorkflowStartOptions {
 }
 export interface UseWorkflowStartResult extends Omit<UseFlowSessionResult, "start" | "listHistory"> {
     workflow: Workflow | null;
-    startType: FlowStartType | "MANUAL";
+    startType: WorkflowStartType | "MANUAL";
     inputSchema: Record<string, unknown> | null;
     inputUiSchema: Record<string, unknown> | null;
     isLoadingWorkflow: boolean;

package/dist/record-display.d.ts

@@ -0,0 +1,20 @@
+import type { ColumnSchema } from "./types.js";
+export interface RecordDetailFieldGroupDefinition {
+    label: string;
+    fields: string[];
+}
+export declare function detectRecordTitleColumn(columns: ColumnSchema[]): ColumnSchema | undefined;
+export declare function detectRecordDescriptionColumn(columns: ColumnSchema[]): ColumnSchema | undefined;
+export declare function detectRecordStatusColumn(columns: ColumnSchema[]): ColumnSchema | undefined;
+export declare function isDefaultRecordDetailHiddenField(name: string): boolean;
+export declare function buildDefaultRecordDetailFieldGroups(columns: ColumnSchema[], options?: {
+    hiddenFields?: string[];
+    titleField?: string;
+    descriptionField?: string;
+    statusField?: string;
+    identifierField?: string;
+}): RecordDetailFieldGroupDefinition[];
+export declare function humanizeRecordFieldName(value: string): string;
+export declare function formatRecordPlainValue(value: unknown): string;
+export declare function formatRecordDisplayValue(value: unknown): string;
+export declare function formatRecordDateDisplayValue(value: unknown, options?: Intl.DateTimeFormatOptions): string;

package/dist/record-display.js

@@ -0,0 +1,78 @@
+export function detectRecordTitleColumn(columns) {
+    return columns.find((column) => !column.system && !column.auto && !column.computed && /title|name|subject|label/i.test(column.name));
+}
+export function detectRecordDescriptionColumn(columns) {
+    return columns.find((column) => !column.system
+        && !column.auto
+        && !column.computed
+        && column.type === "TEXT"
+        && /description|summary|body|content|notes|reason/i.test(column.name));
+}
+export function detectRecordStatusColumn(columns) {
+    return columns.find((column) => /status|state|stage/i.test(column.name));
+}
+export function isDefaultRecordDetailHiddenField(name) {
+    return name === "id" || name === "created_at" || name === "updated_at";
+}
+export function buildDefaultRecordDetailFieldGroups(columns, options = {}) {
+    const excluded = new Set([
+        ...(options.hiddenFields ?? []),
+        options.titleField,
+        options.descriptionField,
+        options.statusField,
+        options.identifierField,
+    ].filter((value) => Boolean(value)));
+    const displayable = columns.filter((column) => !column.system
+        && !column.auto
+        && !column.computed
+        && !isDefaultRecordDetailHiddenField(column.name)
+        && !excluded.has(column.name));
+    if (displayable.length === 0)
+        return [];
+    return [
+        {
+            label: "Details",
+            fields: displayable.map((column) => column.name),
+        },
+    ];
+}
+export function humanizeRecordFieldName(value) {
+    return value
+        .replace(/[_\.]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+export function formatRecordPlainValue(value) {
+    if (value == null || value === "")
+        return "";
+    if (value instanceof Date)
+        return formatRecordDateDisplayValue(value);
+    if (typeof value === "boolean")
+        return value ? "Yes" : "No";
+    if (typeof value === "number")
+        return value.toLocaleString();
+    if (Array.isArray(value))
+        return value.map(formatRecordPlainValue).filter(Boolean).join(", ");
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+export function formatRecordDisplayValue(value) {
+    return formatRecordPlainValue(value) || "Not set";
+}
+export function formatRecordDateDisplayValue(value, options) {
+    if (value == null || value === "")
+        return "Not set";
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(date.getTime()))
+        return String(value);
+    return new Intl.DateTimeFormat(undefined, {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        ...options,
+    }).format(date);
+}

package/dist/record-form.d.ts

@@ -22,9 +22,13 @@ export interface BuildRecordPayloadResult {
     errors: Record<string, string>;
     isValid: boolean;
 }
+export declare const DEFAULT_RECORD_FORM_HIDDEN_FIELDS: readonly ["id", "created_at", "updated_at", "creator_user_id", "sort_order"];
 export declare function getRecordFieldKind(column: ColumnSchema): RecordSchemaFieldKind;
 export declare function buildRecordSchemaFields(table: Table): RecordSchemaField[];
 export declare function getEditableRecordFields(table: Table): RecordSchemaField[];
+export declare function orderRecordSchemaFields<T extends {
+    name: string;
+}>(fields: T[], fieldOrder?: string[]): T[];
 export declare function formatRecordValueForForm(column: ColumnSchema, value: unknown): unknown;
 export declare function buildRecordFormValues(table: Table, values?: Record<string, unknown>): Record<string, unknown>;
 export declare function buildRecordPayload(table: Table, values: Record<string, unknown>, options?: BuildRecordPayloadOptions): BuildRecordPayloadResult;

package/dist/record-form.js

@@ -1,5 +1,12 @@
 import { parseForeignKeyReference } from "./datastore-query.js";
 import { DatastoreDataType } from "./types.js";
+export const DEFAULT_RECORD_FORM_HIDDEN_FIELDS = [
+    "id",
+    "created_at",
+    "updated_at",
+    "creator_user_id",
+    "sort_order",
+];
 function sentenceCase(value) {
     return value
         .replace(/_/g, " ")
@@ -101,6 +108,15 @@ export function buildRecordSchemaFields(table) {
 export function getEditableRecordFields(table) {
     return buildRecordSchemaFields(table).filter((field) => !field.readOnly);
 }
+export function orderRecordSchemaFields(fields, fieldOrder) {
+    if (!fieldOrder?.length)
+        return fields;
+    const ordered = fieldOrder
+        .map((name) => fields.find((field) => field.name === name))
+        .filter((field) => field !== undefined);
+    const remaining = fields.filter((field) => !fieldOrder.includes(field.name));
+    return [...ordered, ...remaining];
+}
 export function formatRecordValueForForm(column, value) {
     const kind = getRecordFieldKind(column);
     if (value === null || typeof value === "undefined") {

package/dist/types.d.ts

@@ -52,6 +52,8 @@ export type TaskMessage = TaskMessageResponse;
 export type FunctionRun = FunctionRunResponse;
 export type FlowRun = FlowRunEntity;
 export type Workflow = FlowResponse;
+export type WorkflowStart = Workflow["start"];
+export type WorkflowStartType = NonNullable<WorkflowStart>["type"];
 export type Table = TableResponse;
 export type TableColumn = ColumnSchema;
 export type DatastoreQueryResult = DatastoreQueryResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemma-sdk",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "description": "Official TypeScript SDK for Lemma pod-scoped APIs",
   "type": "module",
   "main": "dist/index.js",

package/dist/openapi_client/models/EmailSurfaceConfigCreate.d.ts

@@ -1,5 +0,0 @@
-export type EmailSurfaceConfigCreate = {
-    account_id?: (string | null);
-    inbox_email?: (string | null);
-    type?: string;
-};

package/dist/openapi_client/models/FlowInstallEntity.d.ts

@@ -1,16 +0,0 @@
-import type { FlowStart_Output } from './FlowStart_Output.js';
-/**
- * Represents an installed flow instance.
- * Associate a Flow definition with a specific Trigger (Schedule or Event).
- */
-export type FlowInstallEntity = {
-    created_at?: string;
-    flow_id: string;
-    flow_start: FlowStart_Output;
-    id?: string;
-    is_active?: boolean;
-    pod_id: string;
-    trigger_id?: (string | null);
-    updated_at?: string;
-    user_id: string;
-};

package/dist/openapi_client/models/FlowStartType.d.ts

@@ -1,6 +0,0 @@
-export declare enum FlowStartType {
-    MANUAL = "MANUAL",
-    SCHEDULED = "SCHEDULED",
-    EVENT = "EVENT",
-    DATASTORE_EVENT = "DATASTORE_EVENT"
-}

package/dist/openapi_client/models/FlowStartType.js

@@ -1,11 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export var FlowStartType;
-(function (FlowStartType) {
-    FlowStartType["MANUAL"] = "MANUAL";
-    FlowStartType["SCHEDULED"] = "SCHEDULED";
-    FlowStartType["EVENT"] = "EVENT";
-    FlowStartType["DATASTORE_EVENT"] = "DATASTORE_EVENT";
-})(FlowStartType || (FlowStartType = {}));