lemma-sdk 0.2.34 → 0.2.36

package/dist/openapi_client/services/IntegrationsService.d.ts

@@ -52,8 +52,9 @@ export declare class IntegrationsService {
      * OAuth Callback
      * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
      * @param error
-     * @returns AccountResponseSchema Successful Response
+     * @param format
+     * @returns string Successful Response
      * @throws ApiError
      */
-    static integrationOauthCallback(error?: (string | null)): CancelablePromise<AccountResponseSchema>;
+    static integrationOauthCallback(error?: (string | null), format?: (string | null)): CancelablePromise<string>;
 }

package/dist/openapi_client/services/IntegrationsService.js

@@ -103,15 +103,17 @@ export class IntegrationsService {
      * OAuth Callback
      * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
      * @param error
-     * @returns AccountResponseSchema Successful Response
+     * @param format
+     * @returns string Successful Response
      * @throws ApiError
      */
-    static integrationOauthCallback(error) {
+    static integrationOauthCallback(error, format) {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/integrations/connect-requests/oauth/callback',
             query: {
                 'error': error,
+                'format': format,
             },
             errors: {
                 422: `Validation Error`,

package/dist/openapi_client/services/OrganizationsService.d.ts

@@ -8,6 +8,7 @@ import type { OrganizationMemberListResponse } from '../models/OrganizationMembe
 import type { OrganizationMemberResponse } from '../models/OrganizationMemberResponse.js';
 import type { OrganizationMessageResponse } from '../models/OrganizationMessageResponse.js';
 import type { OrganizationResponse } from '../models/OrganizationResponse.js';
+import type { OrganizationSlugAvailabilityResponse } from '../models/OrganizationSlugAvailabilityResponse.js';
 import type { UpdateMemberRoleRequest } from '../models/UpdateMemberRoleRequest.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
 export declare class OrganizationsService {
@@ -62,6 +63,23 @@ export declare class OrganizationsService {
      * @throws ApiError
      */
     static orgInvitationAccept(invitationId: string): CancelablePromise<OrganizationMessageResponse>;
+    /**
+     * Check Organization Slug Availability
+     * Check whether an organization slug is available
+     * @param slug
+     * @returns OrganizationSlugAvailabilityResponse Successful Response
+     * @throws ApiError
+     */
+    static orgSlugAvailability(slug: string): CancelablePromise<OrganizationSlugAvailabilityResponse>;
+    /**
+     * Get Suggested Organizations
+     * Get auto-join organizations matching the current user's email domain
+     * @param limit
+     * @param pageToken
+     * @returns OrganizationListResponse Successful Response
+     * @throws ApiError
+     */
+    static orgSuggested(limit?: number, pageToken?: (string | null)): CancelablePromise<OrganizationListResponse>;
     /**
      * Get Organization
      * Get organization details

package/dist/openapi_client/services/OrganizationsService.js

@@ -121,6 +121,46 @@ export class OrganizationsService {
             },
         });
     }
+    /**
+     * Check Organization Slug Availability
+     * Check whether an organization slug is available
+     * @param slug
+     * @returns OrganizationSlugAvailabilityResponse Successful Response
+     * @throws ApiError
+     */
+    static orgSlugAvailability(slug) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/organizations/slug-availability',
+            query: {
+                'slug': slug,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Get Suggested Organizations
+     * Get auto-join organizations matching the current user's email domain
+     * @param limit
+     * @param pageToken
+     * @returns OrganizationListResponse Successful Response
+     * @throws ApiError
+     */
+    static orgSuggested(limit = 100, pageToken) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/organizations/suggested',
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * Get Organization
      * Get organization details

package/dist/openapi_client/services/WorkflowsService.d.ts

@@ -3,6 +3,7 @@ import type { FlowResponse } from '../models/FlowResponse.js';
 import type { FlowRunEntity } from '../models/FlowRunEntity.js';
 import type { WorkflowCreateRequest } from '../models/WorkflowCreateRequest.js';
 import type { WorkflowGraphUpdateRequest } from '../models/WorkflowGraphUpdateRequest.js';
+import type { WorkflowInstallListResponse } from '../models/WorkflowInstallListResponse.js';
 import type { WorkflowInstallRequest } from '../models/WorkflowInstallRequest.js';
 import type { WorkflowListResponse } from '../models/WorkflowListResponse.js';
 import type { WorkflowRunListResponse } from '../models/WorkflowRunListResponse.js';
@@ -115,6 +116,15 @@ export declare class WorkflowsService {
      * @throws ApiError
      */
     static workflowInstallCreate(podId: string, workflowName: string, requestBody: WorkflowInstallRequest): CancelablePromise<FlowInstallResponse>;
+    /**
+     * List Workflow Installs
+     * List the current user's installations for a workflow.
+     * @param podId
+     * @param workflowName
+     * @returns WorkflowInstallListResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowInstallList(podId: string, workflowName: string): CancelablePromise<WorkflowInstallListResponse>;
     /**
      * Uninstall Workflow
      * Remove a previously created workflow installation binding.

package/dist/openapi_client/services/WorkflowsService.js

@@ -255,6 +255,27 @@ export class WorkflowsService {
             },
         });
     }
+    /**
+     * List Workflow Installs
+     * List the current user's installations for a workflow.
+     * @param podId
+     * @param workflowName
+     * @returns WorkflowInstallListResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowInstallList(podId, workflowName) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/installs',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * Uninstall Workflow
      * Remove a previously created workflow installation binding.

package/dist/react/index.d.ts

@@ -38,18 +38,32 @@ export { useFiles } from "./useFiles.js";
 export type { UseFilesOptions, UseFilesResult } from "./useFiles.js";
 export { useFile } from "./useFile.js";
 export type { UseFileOptions, UseFileResult } from "./useFile.js";
+export { useDatastoreQuery } from "./useDatastoreQuery.js";
+export type { UseDatastoreQueryOptions, UseDatastoreQueryResult, } from "./useDatastoreQuery.js";
+export { useUploadFile } from "./useUploadFile.js";
+export type { UploadFileInput, UseUploadFileOptions, UseUploadFileResult, } from "./useUploadFile.js";
+export { useUpdateFile } from "./useUpdateFile.js";
+export type { UpdateFileInput, UseUpdateFileOptions, UseUpdateFileResult, } from "./useUpdateFile.js";
+export { useDeleteFile } from "./useDeleteFile.js";
+export type { UseDeleteFileOptions, UseDeleteFileResult } from "./useDeleteFile.js";
+export { useCreateFolder } from "./useCreateFolder.js";
+export type { CreateFolderInput, UseCreateFolderOptions, UseCreateFolderResult, } from "./useCreateFolder.js";
 export { useFileSearch } from "./useFileSearch.js";
 export type { UseFileSearchOptions, UseFileSearchResult } from "./useFileSearch.js";
 export { useFileTree } from "./useFileTree.js";
 export type { UseFileTreeOptions, UseFileTreeResult } from "./useFileTree.js";
 export { useFilePreview } from "./useFilePreview.js";
 export type { FilePreviewMode, UseFilePreviewOptions, UseFilePreviewResult, } from "./useFilePreview.js";
+export { useGlobalSearch } from "./useGlobalSearch.js";
+export type { GlobalSearchFileResult, GlobalSearchFilesSource, GlobalSearchRecordResult, GlobalSearchResult, GlobalSearchTableSource, UseGlobalSearchOptions, UseGlobalSearchResult, } from "./useGlobalSearch.js";
 export { useTables } from "./useTables.js";
 export type { UseTablesOptions, UseTablesResult } from "./useTables.js";
 export { useTable } from "./useTable.js";
 export type { UseTableOptions, UseTableResult } from "./useTable.js";
 export { useRecords } from "./useRecords.js";
 export type { UseRecordsOptions, UseRecordsResult } from "./useRecords.js";
+export { useRecordAggregates } from "./useRecordAggregates.js";
+export type { RecordAggregateMetric, RecordAggregateOrderBy, UseRecordAggregatesOptions, UseRecordAggregatesResult, } from "./useRecordAggregates.js";
 export { useRecord } from "./useRecord.js";
 export type { UseRecordOptions, UseRecordResult } from "./useRecord.js";
 export { useCreateRecord } from "./useCreateRecord.js";

package/dist/react/index.js

@@ -18,12 +18,19 @@ export { useCurrentUser } from "./useCurrentUser.js";
 export { usePodAccess } from "./usePodAccess.js";
 export { useFiles } from "./useFiles.js";
 export { useFile } from "./useFile.js";
+export { useDatastoreQuery } from "./useDatastoreQuery.js";
+export { useUploadFile } from "./useUploadFile.js";
+export { useUpdateFile } from "./useUpdateFile.js";
+export { useDeleteFile } from "./useDeleteFile.js";
+export { useCreateFolder } from "./useCreateFolder.js";
 export { useFileSearch } from "./useFileSearch.js";
 export { useFileTree } from "./useFileTree.js";
 export { useFilePreview } from "./useFilePreview.js";
+export { useGlobalSearch } from "./useGlobalSearch.js";
 export { useTables } from "./useTables.js";
 export { useTable } from "./useTable.js";
 export { useRecords } from "./useRecords.js";
+export { useRecordAggregates } from "./useRecordAggregates.js";
 export { useRecord } from "./useRecord.js";
 export { useCreateRecord } from "./useCreateRecord.js";
 export { useUpdateRecord } from "./useUpdateRecord.js";

package/dist/react/sql-utils.d.ts

@@ -0,0 +1,8 @@
+import type { RecordFilter } from "../types.js";
+export declare function quoteIdentifierPath(value: string): string;
+export declare function isSimpleIdentifierPath(value: string): boolean;
+export declare function renderIdentifierPath(value: string): string;
+export declare function escapeSqlString(value: string): string;
+export declare function encodeSqlValue(value: unknown): string;
+export declare function renderRecordFilter(filter: RecordFilter): string;
+export declare function renderRecordFilters(filters?: RecordFilter[]): string;

package/dist/react/sql-utils.js

@@ -0,0 +1,62 @@
+function quoteIdentifierPart(value) {
+    return `"${value.replace(/"/g, "\"\"")}"`;
+}
+export function quoteIdentifierPath(value) {
+    return value
+        .split(".")
+        .map((part) => (part === "*" ? part : quoteIdentifierPart(part)))
+        .join(".");
+}
+export function isSimpleIdentifierPath(value) {
+    return /^[A-Za-z_][A-Za-z0-9_$]*(\.(\*|[A-Za-z_][A-Za-z0-9_$]*))*$/.test(value);
+}
+export function renderIdentifierPath(value) {
+    return isSimpleIdentifierPath(value) ? quoteIdentifierPath(value) : value;
+}
+export function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}
+export function encodeSqlValue(value) {
+    if (value === null || typeof value === "undefined")
+        return "NULL";
+    if (typeof value === "boolean")
+        return value ? "TRUE" : "FALSE";
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error("SQL values must be finite numbers.");
+        }
+        return String(value);
+    }
+    if (typeof value === "bigint")
+        return String(value);
+    if (value instanceof Date)
+        return `'${escapeSqlString(value.toISOString())}'`;
+    if (Array.isArray(value)) {
+        return `(${value.map((entry) => encodeSqlValue(entry)).join(", ")})`;
+    }
+    if (typeof value === "object") {
+        return `'${escapeSqlString(JSON.stringify(value))}'`;
+    }
+    return `'${escapeSqlString(String(value))}'`;
+}
+export function renderRecordFilter(filter) {
+    const field = filter.field?.trim();
+    if (!field) {
+        throw new Error("Record filters require a field.");
+    }
+    const operator = filter.op.trim().toUpperCase();
+    const lhs = renderIdentifierPath(field);
+    const values = Array.isArray(filter.values) ? filter.values : undefined;
+    if ((operator === "IN" || operator === "NOT IN") && values) {
+        return `${lhs} ${operator} ${encodeSqlValue(values)}`;
+    }
+    if ((operator === "IS" || operator === "IS NOT") && typeof filter.value === "undefined") {
+        return `${lhs} ${operator} NULL`;
+    }
+    return `${lhs} ${operator} ${encodeSqlValue(filter.value)}`;
+}
+export function renderRecordFilters(filters) {
+    if (!filters?.length)
+        return "";
+    return filters.map((filter) => `(${renderRecordFilter(filter)})`).join(" AND ");
+}

package/dist/react/useCreateFolder.d.ts

@@ -0,0 +1,22 @@
+import type { LemmaClient } from "../client.js";
+import type { FileResponse } from "../types.js";
+export interface CreateFolderInput {
+    directoryPath?: string;
+    parentId?: string;
+    description?: string;
+}
+export interface UseCreateFolderOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    onSuccess?: (folder: FileResponse) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseCreateFolderResult<TFile extends FileResponse = FileResponse> {
+    createdFolder: TFile | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    createFolder: (name: string, options?: CreateFolderInput) => Promise<TFile | null>;
+    reset: () => void;
+}
+export declare function useCreateFolder<TFile extends FileResponse = FileResponse>({ client, podId, enabled, onSuccess, onError, }: UseCreateFolderOptions): UseCreateFolderResult<TFile>;

package/dist/react/useCreateFolder.js

@@ -0,0 +1,47 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useCreateFolder({ client, podId, enabled = true, onSuccess, onError, }) {
+    const [createdFolder, setCreatedFolder] = 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 createFolder = useCallback(async (name, options = {}) => {
+        const trimmedName = name.trim();
+        if (!enabled || trimmedName.length === 0) {
+            return null;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextFolder = await scopedClient.files.folder.create(trimmedName, options);
+            setCreatedFolder(nextFolder);
+            onSuccessRef.current?.(nextFolder);
+            return nextFolder;
+        }
+        catch (createError) {
+            const normalized = normalizeError(createError, "Failed to create folder.");
+            setError(normalized);
+            onErrorRef.current?.(createError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId]);
+    const reset = useCallback(() => {
+        setCreatedFolder(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        createdFolder,
+        isSubmitting,
+        error,
+        createFolder,
+        reset,
+    }), [createFolder, createdFolder, error, isSubmitting, reset]);
+}

package/dist/react/useDatastoreQuery.d.ts

@@ -0,0 +1,22 @@
+import type { LemmaClient } from "../client.js";
+import type { DatastoreQueryResponse } from "../types.js";
+export interface UseDatastoreQueryOptions {
+    client: LemmaClient;
+    podId?: string;
+    query?: string | null;
+    enabled?: boolean;
+    autoLoad?: boolean;
+}
+export interface UseDatastoreQueryResult<TRow extends Record<string, unknown> = Record<string, unknown>> {
+    response: DatastoreQueryResponse | null;
+    items: TRow[];
+    total: number;
+    sql: string;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        query?: string | null;
+    }) => Promise<TRow[]>;
+    reset: () => void;
+}
+export declare function useDatastoreQuery<TRow extends Record<string, unknown> = Record<string, unknown>>({ client, podId, query, enabled, autoLoad, }: UseDatastoreQueryOptions): UseDatastoreQueryResult<TRow>;

package/dist/react/useDatastoreQuery.js

@@ -0,0 +1,67 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useDatastoreQuery({ client, podId, query = null, enabled = true, autoLoad = true, }) {
+    const [response, setResponse] = useState(null);
+    const [sql, setSql] = useState("");
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const trimmedQuery = typeof query === "string" ? query.trim() : "";
+    const isEnabled = enabled && trimmedQuery.length > 0;
+    const reset = useCallback(() => {
+        setResponse(null);
+        setSql("");
+        setError(null);
+        setIsLoading(false);
+    }, []);
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        const nextQuery = typeof overrides.query === "string"
+            ? overrides.query.trim()
+            : trimmedQuery;
+        if (!enabled || nextQuery.length === 0) {
+            reset();
+            return [];
+        }
+        setIsLoading(true);
+        setError(null);
+        setSql(nextQuery);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextResponse = await scopedClient.datastore.query(nextQuery);
+            if (signal?.aborted)
+                return [];
+            setResponse(nextResponse);
+            return (nextResponse.items ?? []);
+        }
+        catch (queryError) {
+            if (signal?.aborted)
+                return [];
+            setError(normalizeError(queryError, "Failed to execute datastore query."));
+            setResponse(null);
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, enabled, podId, reset, trimmedQuery]);
+    useEffect(() => {
+        if (!isEnabled || !autoLoad) {
+            if (!isEnabled)
+                reset();
+            return;
+        }
+        const controller = new AbortController();
+        void refresh({}, controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, isEnabled, refresh, reset]);
+    return useMemo(() => ({
+        response,
+        items: (response?.items ?? []),
+        total: response?.total ?? 0,
+        sql,
+        isLoading,
+        error,
+        refresh,
+        reset,
+    }), [error, isLoading, refresh, reset, response, sql]);
+}

package/dist/react/useDeleteFile.d.ts

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

package/dist/react/useDeleteFile.js

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

package/dist/react/useGlobalSearch.d.ts

@@ -0,0 +1,62 @@
+import type { LemmaClient } from "../client.js";
+import type { FileSearchResultSchema, RecordFilter, SearchMethod } from "../types.js";
+export interface GlobalSearchTableSource {
+    key?: string;
+    tableName: string;
+    label?: string;
+    searchFields: string[];
+    displayField?: string;
+    subtitleField?: string;
+    limit?: number;
+    filters?: RecordFilter[];
+}
+export interface GlobalSearchFilesSource {
+    enabled?: boolean;
+    label?: string;
+    limit?: number;
+    searchMethod?: SearchMethod;
+}
+export interface GlobalSearchRecordResult {
+    kind: "record";
+    sourceKey: string;
+    sourceLabel: string;
+    tableName: string;
+    id: string;
+    title: string;
+    subtitle: string | null;
+    record: Record<string, unknown>;
+}
+export interface GlobalSearchFileResult {
+    kind: "file";
+    sourceKey: string;
+    sourceLabel: string;
+    path: string;
+    title: string;
+    subtitle: string | null;
+    result: FileSearchResultSchema;
+}
+export type GlobalSearchResult = GlobalSearchRecordResult | GlobalSearchFileResult;
+export interface UseGlobalSearchOptions {
+    client: LemmaClient;
+    podId?: string;
+    query?: string;
+    tables?: GlobalSearchTableSource[];
+    files?: GlobalSearchFilesSource | false;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    minQueryLength?: number;
+}
+export interface UseGlobalSearchResult {
+    results: GlobalSearchResult[];
+    recordResults: GlobalSearchRecordResult[];
+    fileResults: GlobalSearchFileResult[];
+    totalResults: number;
+    sourceErrors: Record<string, Error>;
+    isLoading: boolean;
+    error: Error | null;
+    search: (overrides?: {
+        query?: string;
+    }) => Promise<GlobalSearchResult[]>;
+    reset: () => void;
+}
+export declare function useGlobalSearch({ client, podId, query, tables, files, enabled, autoLoad, minQueryLength, }: UseGlobalSearchOptions): UseGlobalSearchResult;