@cargo-ai/api 1.0.1

package/build/src/api/orchestration/index.js

@@ -0,0 +1,625 @@
+import { nullToUndefined } from "cargo-utils";
+import { getErrorWithReasonErrorMessage, } from "../../fetcher/index.js";
+import { Orchestration } from "../../store/index.js";
+export const buildOrchestrationApi = ({ fetcher, }) => {
+    async function allWorkflows() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/orchestration/workflows/list",
+        });
+        return result;
+    }
+    async function createPlay(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/orchestration/plays",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodCreatePlayErrorReason, {
+                modelNotFound: "Model not found.",
+                failedToCreateSegment: "Fail to create segment",
+                folderNotFound: "Folder not found.",
+                failedToSchedule: "Fail to schedule.",
+                invalidFilter: "Invalid filter.",
+                integrationNotCompatible: "Integration is not compatible.",
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+            });
+        }
+    }
+    async function allPlays() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/orchestration/plays/list",
+        });
+        return result;
+    }
+    async function removePlay(uuid) {
+        try {
+            await fetcher.fetch({
+                method: "delete",
+                endpoint: `/orchestration/plays/${uuid}`,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodRemovePlayErrorReason, {
+                playNotFound: "Play not found.",
+                failedToRemoveSegment: "Failed to remove segment linked to play.",
+            });
+        }
+    }
+    async function updatePlay(payload) {
+        const { uuid, ...other } = payload;
+        try {
+            const result = await fetcher.fetch({
+                method: "put",
+                endpoint: `/orchestration/plays/${uuid}`,
+                payload: other,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodUpdatePlayErrorReason, {
+                playNotFound: "Play not found.",
+                playNotDeployed: "You cannot enable a non-deployed play.",
+                failedToUpdateSegment: "Failed to update segment linked to play.",
+                folderNotFound: "Folder not found.",
+                failedToSchedule: "Fail to schedule.",
+                invalidFilter: "Invalid filter.",
+                integrationNotCompatible: "Integration is not compatible.",
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                modelNotFound: "Model not found.",
+                segmentNotFound: "Segment not found.",
+            });
+        }
+    }
+    async function createTool(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/tools",
+            payload,
+        });
+        return result;
+    }
+    async function allTools() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/orchestration/tools/list",
+        });
+        return result;
+    }
+    async function removeTool(uuid) {
+        try {
+            await fetcher.fetch({
+                method: "delete",
+                endpoint: `/orchestration/tools/${uuid}`,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodRemoveToolErrorReason, {
+                toolNotFound: "Tool not found.",
+                toolIsReadOnly: "Tool is read only.",
+            });
+        }
+    }
+    async function updateTool(payload) {
+        const { uuid, ...other } = payload;
+        try {
+            const result = await fetcher.fetch({
+                method: "put",
+                endpoint: `/orchestration/tools/${uuid}`,
+                payload: other,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodUpdateToolErrorReason, {
+                toolNotFound: "Tool not found.",
+                toolIsReadOnly: "Tool is read only.",
+                folderNotFound: "Folder not found.",
+            });
+        }
+    }
+    async function computeNode(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/nodes/compute",
+            payload,
+            replaceNullByUndefined: false,
+        });
+        // Then cast the fields that should not keep the null values from the backend
+        return {
+            ...nullToUndefined(result),
+            computedConfig: result.computedConfig,
+        };
+    }
+    async function executeNode(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/orchestration/nodes/execute",
+                payload,
+                replaceNullByUndefined: false,
+            });
+            // Then cast the fields that should not keep the null values from the backend
+            if (result.status === "pending") {
+                return nullToUndefined(result);
+            }
+            const parsedGroupItems = result.groupItems !== undefined
+                ? result.groupItems.map((groupItem) => {
+                    const executions = Object.entries(groupItem.executions).reduce((currentExecutions, [nodeUuid, executionResult]) => {
+                        if (executionResult.outcome === "executed") {
+                            currentExecutions[nodeUuid] = {
+                                ...nullToUndefined(executionResult),
+                                data: executionResult.data,
+                            };
+                            return currentExecutions;
+                        }
+                        currentExecutions[nodeUuid] = nullToUndefined(executionResult);
+                        return currentExecutions;
+                    }, {});
+                    const computedConfigs = Object.entries(groupItem.computedConfigs).reduce((currentComputedConfigs, [nodeUuid, computedConfigResult]) => {
+                        if (computedConfigResult.outcome === "computed") {
+                            currentComputedConfigs[nodeUuid] = {
+                                ...nullToUndefined(computedConfigResult),
+                                computedConfig: computedConfigResult.computedConfig,
+                            };
+                            return currentComputedConfigs;
+                        }
+                        currentComputedConfigs[nodeUuid] =
+                            nullToUndefined(computedConfigResult);
+                        return currentComputedConfigs;
+                    }, {});
+                    return {
+                        ...nullToUndefined(groupItem),
+                        item: groupItem.item,
+                        executions,
+                        computedConfigs,
+                    };
+                })
+                : undefined;
+            if (result.status === "error") {
+                return {
+                    ...nullToUndefined(result),
+                    groupItems: parsedGroupItems,
+                };
+            }
+            return {
+                ...nullToUndefined(result),
+                data: result.data,
+                groupItems: parsedGroupItems,
+            };
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodExecuteNodeErrorReason, {
+                releaseNotFound: "Release not found.",
+            });
+        }
+    }
+    async function previewBatch(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/batches/preview`,
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodPreviewBatchErrorReason, {
+                workflowNotFound: "Workflow not found.",
+                segmentNotFound: "Segment not found.",
+                modelLinkedToWorkflow: "A model is linked to this workflow.",
+                noModelLinkedToWorkflow: "No model is linked to this workflow.",
+                failedToFetchFromClient: "Fail to fetch records.",
+            });
+        }
+    }
+    async function createBatch(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/batches`,
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodCreateBatchErrorReason, {
+                workflowNotFound: "Workflow not found.",
+                invalidReleaseOrCustomNodes: "Invalid release or custom nodes.",
+                nodesNotFound: "Unable to retrieve nodes.",
+                startNodeNotFound: "Start node not found.",
+                failedToStart: "Fail to start.",
+                notEnoughCredits: "Not enough credits.",
+                dataError: (data) => {
+                    if (data.dataError === undefined) {
+                        return undefined;
+                    }
+                    const dataErrorReason = data.dataError.reason;
+                    return {
+                        failedToGetSegment: "Fail to get segment.",
+                        noRecords: "No records.",
+                        failedToGetSegmentChange: "Fail to get segment change.",
+                        invalidChange: "Invalid change.",
+                        invalidChangeKinds: "Invalid changes.",
+                        invalidData: "Invalid data.",
+                    }[dataErrorReason];
+                },
+            });
+        }
+    }
+    async function listBatches(payload) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/orchestration/batches/list",
+            params: payload,
+        });
+        return result;
+    }
+    async function getBatch(uuid) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `/orchestration/batches/${uuid}`,
+        });
+        return result;
+    }
+    async function cancelBatch(uuid) {
+        try {
+            await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/batches/${uuid}/cancel`,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodCancelBatchErrorReason, {
+                batchNotFound: "Batch not found.",
+                batchAlreadyFinished: "Batch already finished.",
+                failedToStart: "Failed to cancel batch.",
+            });
+        }
+    }
+    async function downloadBatch(payload) {
+        const { uuid, outputNodeSlug } = payload;
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/batches/${uuid}/download`,
+                payload: {
+                    outputNodeSlug,
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodDownloadBatchErrorReason, {
+                batchNotFound: "Batch not found.",
+                batchNotFinished: "Batch not finished.",
+                batchNotSupported: "Batch not supported.",
+            });
+        }
+    }
+    async function createRun(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/orchestration/runs",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodCreateRunErrorReason, {
+                workflowNotFound: "Workflow not found.",
+                invalidReleaseOrCustomNodes: "Invalid release or custom nodes.",
+                nodesNotFound: "Unable to retrieve nodes.",
+                invalidData: "Invalid data.",
+                startNodeNotFound: "Start node not found.",
+                failedToStart: "Failed to start.",
+                notEnoughCredits: "Not enough credits.",
+            });
+        }
+    }
+    async function cancelRuns(payload) {
+        try {
+            await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/runs/cancel`,
+                payload,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodCancelRunsErrorReason, {
+                failedToStart: "Failed to cancel runs.",
+            });
+        }
+    }
+    async function getRun(uuid) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `/orchestration/runs/${uuid}`,
+            replaceNullByUndefined: false,
+        });
+        return {
+            ...nullToUndefined(result),
+            runContext: result.runContext,
+            runComputedConfigs: result.runComputedConfigs,
+        };
+    }
+    async function listRuns(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/runs/list",
+            payload,
+        });
+        return result;
+    }
+    async function countRuns(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/runs/count",
+            payload,
+        });
+        return result;
+    }
+    async function downloadRuns(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/runs/download",
+            payload,
+        });
+        return result;
+    }
+    async function getRunMetrics(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: `/orchestration/runs/metrics`,
+            payload,
+        });
+        return result;
+    }
+    async function listRecords(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/records/list",
+            payload,
+        });
+        return result;
+    }
+    async function countRecords(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/records/count",
+            payload,
+        });
+        return result;
+    }
+    async function downloadRecords(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/orchestration/records/download",
+            payload,
+        });
+        return result;
+    }
+    async function getRecordMetrics(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: `/orchestration/records/metrics`,
+            payload,
+        });
+        return result;
+    }
+    async function cancelRecords(payload) {
+        try {
+            await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/records/cancel`,
+                payload,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodCancelRecordsErrorReason, {
+                failedToStart: "Failed to cancel runs.",
+                tooManyRecordsSelected: "Selecting more than 2000 records is not supported.",
+            });
+        }
+    }
+    async function getRelease(uuid) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `/orchestration/releases/${uuid}`,
+            replaceNullByUndefined: false,
+        });
+        // Then cast the fields that should not keep the null values from the backend
+        return {
+            ...nullToUndefined(result),
+            release: {
+                ...nullToUndefined(result.release),
+                testRecords: result.release.testRecords,
+            },
+        };
+    }
+    async function listReleases(payload) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/orchestration/releases/list",
+            params: payload,
+            replaceNullByUndefined: false,
+        });
+        // Then cast the fields that should not keep the null values from the backend
+        return {
+            ...nullToUndefined(result),
+            releases: result.releases.map((release) => {
+                return {
+                    ...nullToUndefined(release),
+                    testRecords: release.testRecords,
+                };
+            }),
+        };
+    }
+    async function getDraftRelease(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "get",
+                endpoint: "/orchestration/releases/draft",
+                params: payload,
+                replaceNullByUndefined: false,
+            });
+            // Then cast the fields that should not keep the null values from the backend
+            return {
+                ...nullToUndefined(result),
+                release: {
+                    ...nullToUndefined(result.release),
+                    testRecords: result.release.testRecords,
+                },
+            };
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodGetDraftReleaseErrorReason, {
+                workflowNotFound: "Workflow not found.",
+            });
+        }
+    }
+    async function deployDraftRelease(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/releases/draft/deploy`,
+                payload,
+                replaceNullByUndefined: false,
+            });
+            // Then cast the fields that should not keep the null values from the backend
+            return {
+                ...nullToUndefined(result),
+                release: {
+                    ...nullToUndefined(result.release),
+                    testRecords: result.release.testRecords,
+                },
+            };
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodDeployDraftReleaseErrorReason, {
+                workflowNotFound: "Workflow not found.",
+                draftReleaseNotFound: "Draft release not found.",
+                draftReleaseNodesAreInvalid: "The nodes are invalid.",
+                duplicatedReleaseVersion: "Release version already used.",
+                failedToReconciliateNodes: "Failed to reconciliate nodes.",
+            });
+        }
+    }
+    async function updateDraftRelease(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: `/orchestration/releases/draft/update`,
+                payload,
+                replaceNullByUndefined: false,
+            });
+            // Then cast the fields that should not keep the null values from the backend
+            return {
+                ...nullToUndefined(result),
+                release: {
+                    ...nullToUndefined(result.release),
+                    testRecords: result.release.testRecords,
+                },
+            };
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodUpdateDraftReleaseErrorReason, {
+                workflowNotFound: "Workflow not found.",
+                draftReleaseNotFound: "Workflow draft release not found.",
+                invalidParent: "Invalid parent workflow release.",
+                failedToReconciliateNodes: "Failed to reconciliate nodes.",
+            });
+        }
+    }
+    async function allTemplates() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `/orchestration/templates/list`,
+        });
+        return result;
+    }
+    async function getTemplate(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "get",
+                endpoint: `/orchestration/templates/${payload.slug}`,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Orchestration.Api.zodGetTemplateErrorReason, {
+                templateNotFound: "Template not found.",
+            });
+        }
+    }
+    return {
+        batch: {
+            list: listBatches,
+            create: createBatch,
+            preview: previewBatch,
+            get: getBatch,
+            cancel: cancelBatch,
+            download: downloadBatch,
+        },
+        workflow: {
+            all: allWorkflows,
+        },
+        play: {
+            create: createPlay,
+            update: updatePlay,
+            remove: removePlay,
+            all: allPlays,
+        },
+        tool: {
+            create: createTool,
+            update: updateTool,
+            remove: removeTool,
+            all: allTools,
+        },
+        release: {
+            list: listReleases,
+            get: getRelease,
+        },
+        draftRelease: {
+            get: getDraftRelease,
+            update: updateDraftRelease,
+            deploy: deployDraftRelease,
+        },
+        run: {
+            create: createRun,
+            list: listRuns,
+            count: countRuns,
+            download: downloadRuns,
+            get: getRun,
+            getMetrics: getRunMetrics,
+            cancel: cancelRuns,
+        },
+        record: {
+            list: listRecords,
+            count: countRecords,
+            download: downloadRecords,
+            getMetrics: getRecordMetrics,
+            cancel: cancelRecords,
+        },
+        node: {
+            compute: computeNode,
+            execute: executeNode,
+        },
+        template: {
+            all: allTemplates,
+            get: getTemplate,
+        },
+    };
+};

package/build/src/api/revenueOrganization/index.d.ts

@@ -0,0 +1,37 @@
+import type { Fetcher } from "../../fetcher/index.js";
+import { RevenueOrganization } from "../../store/index.js";
+interface RevenueOrganizationApiDependencies {
+    fetcher: Fetcher;
+}
+export interface RevenueOrganizationApi {
+    allocation: {
+        get: (uuid: string) => Promise<RevenueOrganization.Api.GetAllocationResult>;
+        list: (payload: RevenueOrganization.Api.ListAllocationsPayload) => Promise<RevenueOrganization.Api.ListAllocationsResult>;
+        remove: (uuid: string) => Promise<void>;
+    };
+    capacity: {
+        create: (payload: RevenueOrganization.Api.CreateCapacityPayload) => Promise<RevenueOrganization.Api.CreateCapacityResult>;
+        get: (uuid: string) => Promise<RevenueOrganization.Api.GetCapacityResult>;
+        all: () => Promise<RevenueOrganization.Api.ListCapacitiesResult>;
+        remove: (uuid: string) => Promise<void>;
+        update: (payload: RevenueOrganization.Api.UpdateCapacityPayload) => Promise<RevenueOrganization.Api.UpdateCapacityResult>;
+    };
+    member: {
+        sync: (payload: RevenueOrganization.Api.SyncMemberPayload) => Promise<void>;
+        archive: (uuid: string) => Promise<RevenueOrganization.Api.ArchiveMemberResult>;
+        get: (uuid: string) => Promise<RevenueOrganization.Api.GetMemberResult>;
+        all: () => Promise<RevenueOrganization.Api.ListMembersResult>;
+        unarchive: (uuid: string) => Promise<RevenueOrganization.Api.UnarchiveMemberResult>;
+        update: (payload: RevenueOrganization.Api.UpdateMemberPayload) => Promise<RevenueOrganization.Api.UpdateMemberResult>;
+    };
+    territory: {
+        create: (payload: RevenueOrganization.Api.CreateTerritoryPayload) => Promise<RevenueOrganization.Api.CreateTerritoryResult>;
+        get: (uuid: string) => Promise<RevenueOrganization.Api.GetTerritoryResult>;
+        all: () => Promise<RevenueOrganization.Api.ListTerritoriesResult>;
+        remove: (uuid: string) => Promise<void>;
+        update: (payload: RevenueOrganization.Api.UpdateTerritoryPayload) => Promise<RevenueOrganization.Api.UpdateTerritoryResult>;
+    };
+}
+export declare const buildRevenueOrganizationApi: ({ fetcher, }: RevenueOrganizationApiDependencies) => RevenueOrganizationApi;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/src/api/revenueOrganization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/revenueOrganization/index.ts"],"names":[],"mappings":"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"}