@membranehq/sdk 0.2.1 → 0.3.0

package/dist/dts/connectors/data-locations/utils.d.ts

@@ -1,5 +1,5 @@
 import { DataSchema } from '../../data-schema';
-import { ConnectorDataLocation, DataCollectionSpec, DataLocationPointer } from '.';
+import { ConnectorDataCollection, DataCollectionSpec, DataLocationPointer } from '.';
 export declare function getDataLocationMethodPath(locationKey: any, methodKey: any): string;
 export declare function dataLocationParametersMatch({ locationParameters, targetParameters, }: {
     locationParameters: Record<string, any>;
@@ -11,7 +11,7 @@ export declare function makeDataLocationPath(pointer: DataLocationPointer): stri
 export declare function makeDataLocationPath(pointer: DataLocationPointer | undefined): string | undefined;
 export declare function makeDataLocationOperationPath(collectionPath: string, operation: string): string;
 export declare function isSameDataLocation(location1: DataLocationPointer, location2: DataLocationPointer): boolean;
-export declare function isDataLocationMethodSupported(location: ConnectorDataLocation, methodKey: string): boolean;
+export declare function isDataLocationMethodSupported(location: ConnectorDataCollection, methodKey: string): boolean;
 export declare function getDataCollectionCreateFields(spec: DataCollectionSpec): DataSchema | undefined;
 export declare function getDataCollectionUpdateFields(spec: DataCollectionSpec): DataSchema | undefined;
 export declare function getWritableFieldsSchema(spec: DataCollectionSpec): DataSchema | undefined;

package/dist/dts/connectors/types.d.ts

@@ -1,7 +1,5 @@
 import { DataSchema } from '../data-schema';
-import { UDM } from '../udm';
 import { ConnectorAuth } from './auth';
-import { DataLocation, DataLocationSpec } from './data-locations';
 import { ConnectorMethodImplementation } from './methods';
 import { ConnectorOperationHandler } from './operations';
 import { ConnectorUdmSpec } from './udm';
@@ -35,15 +33,6 @@ export interface ConnectorUiSpec {
     helpUri?: string;
     test?: boolean;
 }
-export type ConnectorDataUdmSpec = {
-    rootLocation: DataLocation;
-};
-export type ConnectorDataSpec = {
-    rootLocation?: DataLocation;
-    locations?: DataLocationSpec[];
-    udm?: Partial<Record<UDM, ConnectorDataUdmSpec>>;
-    root?: DataLocation;
-} & Partial<Record<UDM, DataLocation>>;
 export type ConnectorApiType = 'openapi' | 'graphql';
 export interface ConnectorSpec {
     key?: string;
@@ -57,7 +46,6 @@ export interface ConnectorSpec {
     ui?: ConnectorUiSpec;
     auth?: ConnectorAuth;
     parametersSchema?: DataSchema;
-    data?: ConnectorDataSpec;
     udms?: string[];
     udm?: Record<string, ConnectorUdmSpec>;
     operations?: ConnectorOperationHandler[];
@@ -66,6 +54,7 @@ export interface ConnectorSpec {
     appUuid?: string;
     knowledgeBaseUuid?: string;
     workspaceId?: string;
+    data?: any;
 }
 export type MinimalConnector = {
     id: string;

package/dist/dts/data-builder/formulas/dataSchemaRef.d.ts

@@ -13,8 +13,8 @@ export declare class DataSchemaRef extends DataBuilderFormulaBase<DataSchemaRefA
     value: any;
     constructor(value: any);
     getValue(): undefined;
-    resolveValue(params: ResolveFormulaParams): Promise<import("../..").DataSchema | undefined>;
-    resolveDataCollection(args: DataSchemaRegArgsDataCollection, params: ResolveFormulaParams): Promise<import("../..").DataSchema | undefined>;
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    resolveDataCollection(args: DataSchemaRegArgsDataCollection, params: ResolveFormulaParams): Promise<any>;
     resolveInternalDataSchema(args: DataSchemaRegArgsInternalDataSchema, params: ResolveFormulaParams): Promise<import("../..").DataSchema | undefined>;
     getSchema(): {
         type: string;

package/dist/dts/data-schema/index.d.ts

@@ -1,5 +1,6 @@
 export * from './create';
 export * from './data-field';
 export * from './merge';
+export * from './schemas';
 export * from './types';
 export * from './utils';

package/dist/dts/data-schema/schemas.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+declare const DataSchemaSchema: any;
+export { DataSchemaSchema };
+export type DataSchemaType = z.infer<typeof DataSchemaSchema>;

package/dist/dts/errors/index.d.ts

@@ -1,5 +1,5 @@
+import { z } from 'zod';
 import { WorkspaceElementReference } from '../workspace-elements';
-import { ErrorDoc } from './error-doc-enum';
 export * from './error-doc-enum';
 export declare enum ErrorType {
     BAD_REQUEST = "bad_request",
@@ -30,15 +30,8 @@ export declare enum ConnectionErrorKey {
 export declare enum ConcurrencyErrorKey {
     LOCK_TIMEOUT = "lock_timeout"
 }
-interface ErrorDataFields {
-    type?: ErrorType;
-    key?: string;
-    message: string;
-    data?: any;
-    doc?: ErrorDoc;
-    stack?: any;
-    causedByError?: ErrorData;
-    logs?: any[];
+export declare const ErrorDataSchema: any;
+interface ErrorDataFields extends z.infer<typeof ErrorDataSchema> {
 }
 type ErrorConstructorArg = string | ErrorDataFields | Error;
 export declare function isIntegrationAppError(error: any): any;

package/dist/dts/flow-runs/flow-node-runs.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { ErrorData } from '../errors';
 export declare enum FlowNodeRunStatus {
     COMPLETED = "completed",
@@ -9,34 +10,365 @@ export interface FlowNodeHandlerRunResponse {
     output?: any;
     errors?: ErrorData[];
 }
-export interface UpstreamFlowNodeRun {
+export declare const UpstreamFlowNodeRunSchema: z.ZodObject<{
+    nodeKey: z.ZodString;
+    runId: z.ZodString;
+    outputId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     nodeKey: string;
     runId: string;
     outputId: string;
+}, {
+    nodeKey: string;
+    runId: string;
+    outputId: string;
+}>;
+export interface UpstreamFlowNodeRun extends z.infer<typeof UpstreamFlowNodeRunSchema> {
 }
-export interface DownstreamFlowNodeRun {
+export declare const DownstreamFlowNodeRunSchema: z.ZodObject<{
+    runId: z.ZodString;
+    nodeKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    nodeKey: string;
     runId: string;
+}, {
     nodeKey: string;
+    runId: string;
+}>;
+export interface DownstreamFlowNodeRun extends z.infer<typeof DownstreamFlowNodeRunSchema> {
 }
-export interface FlowNodeRunParameters {
+export declare const FlowNodeRunParametersSchema: z.ZodObject<{
+    id: z.ZodString;
+    upstreamRuns: z.ZodArray<z.ZodObject<{
+        nodeKey: z.ZodString;
+        runId: z.ZodString;
+        outputId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }>, "many">;
+    input: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    input?: any;
+}, {
     id: string;
-    upstreamRuns: UpstreamFlowNodeRun[];
-    input: any;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    input?: any;
+}>;
+export interface FlowNodeRunParameters extends z.infer<typeof FlowNodeRunParametersSchema> {
 }
-export interface FlowNodeRunOutput {
+export declare const FlowNodeRunOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodString;
+    downstreamRuns: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        nodeKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: string;
     id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}, {
     data: string;
-    downstreamRuns: DownstreamFlowNodeRun[];
+    id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}>;
+export interface FlowNodeRunOutput extends z.infer<typeof FlowNodeRunOutputSchema> {
 }
-export interface FlowNodeRunResult {
+export declare const FlowNodeRunResultSchema: z.ZodObject<{
+    status: z.ZodNativeEnum<typeof FlowNodeRunStatus>;
+    logs: z.ZodArray<z.ZodAny, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodString;
+        downstreamRuns: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            nodeKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            nodeKey: string;
+            runId: string;
+        }, {
+            nodeKey: string;
+            runId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }>, "many">;
+    errors: z.ZodArray<any, "many">;
+}, "strip", z.ZodTypeAny, {
+    logs: any[];
     status: FlowNodeRunStatus;
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    errors: any[];
+}, {
     logs: any[];
-    outputs: FlowNodeRunOutput[];
-    errors: ErrorData[];
+    status: FlowNodeRunStatus;
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    errors: any[];
+}>;
+export interface FlowNodeRunResult extends z.infer<typeof FlowNodeRunResultSchema> {
 }
-export interface FlowNodeRunRecord extends FlowNodeRunParameters, FlowNodeRunResult {
+export declare const FlowNodeRunRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    upstreamRuns: z.ZodArray<z.ZodObject<{
+        nodeKey: z.ZodString;
+        runId: z.ZodString;
+        outputId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }>, "many">;
+    input: z.ZodAny;
+} & {
+    status: z.ZodNativeEnum<typeof FlowNodeRunStatus>;
+    logs: z.ZodArray<z.ZodAny, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodString;
+        downstreamRuns: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            nodeKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            nodeKey: string;
+            runId: string;
+        }, {
+            nodeKey: string;
+            runId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }>, "many">;
+    errors: z.ZodArray<any, "many">;
+}, "strip", z.ZodTypeAny, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    errors: any[];
+    input?: any;
+}, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    errors: any[];
+    input?: any;
+}>;
+export interface FlowNodeRunRecord extends z.infer<typeof FlowNodeRunRecordSchema> {
+}
+export declare const FlowNodeRunOutputWithoutDownstreamRunsSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    id: string;
+}, {
+    data: string;
+    id: string;
+}>;
+export interface FlowNodeRunOutputWithoutDownstreamRuns extends z.infer<typeof FlowNodeRunOutputWithoutDownstreamRunsSchema> {
+}
+export declare const FlowNodeRunOutputMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    downstreamRuns: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        nodeKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}, {
+    id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}>;
+export interface FlowNodeRunOutputMetadata extends z.infer<typeof FlowNodeRunOutputMetadataSchema> {
+}
+export declare const FlowNodeRunRecordWithoutOutputsDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    upstreamRuns: z.ZodArray<z.ZodObject<{
+        nodeKey: z.ZodString;
+        runId: z.ZodString;
+        outputId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }>, "many">;
+    input: z.ZodAny;
+    status: z.ZodNativeEnum<typeof FlowNodeRunStatus>;
+    logs: z.ZodArray<z.ZodAny, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        downstreamRuns: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            nodeKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            nodeKey: string;
+            runId: string;
+        }, {
+            nodeKey: string;
+            runId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }, {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }>, "many">;
+    errors: z.ZodArray<any, "many">;
+}, "strip", z.ZodTypeAny, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    errors: any[];
+    input?: any;
+}, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    errors: any[];
+    input?: any;
+}>;
+export interface FlowNodeRunRecordWithoutOutputsData extends z.infer<typeof FlowNodeRunRecordWithoutOutputsDataSchema> {
 }
-export type FlowNodeRunRecordWithoutOutputsData = FlowNodeRunRecord & {
-    outputs: Omit<FlowNodeRunOutput, 'data'>[];
-};
-export type FlowNodeRunOutputWithoutDownstreamRuns = Omit<FlowNodeRunOutput, 'downstreamRuns'>;

package/dist/dts/flows/schemas.d.ts

@@ -21,12 +21,12 @@ export declare const createFlowInstanceSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }>, "many">>;
         isCustomized: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
@@ -39,8 +39,8 @@ export declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }, {
@@ -53,8 +53,8 @@ export declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }>>>;
@@ -73,8 +73,8 @@ export declare const createFlowInstanceSchema: z.ZodObject<{
     name?: string | undefined;
     userId?: string | undefined;
     integrationId?: string | undefined;
-    connectionId?: string | undefined;
     parameters?: any;
+    connectionId?: string | undefined;
     flowId?: string | undefined;
     instanceKey?: string | undefined;
     nodes?: Record<string, {
@@ -87,8 +87,8 @@ export declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;
@@ -101,8 +101,8 @@ export declare const createFlowInstanceSchema: z.ZodObject<{
     name?: string | undefined;
     userId?: string | undefined;
     integrationId?: string | undefined;
-    connectionId?: string | undefined;
     parameters?: any;
+    connectionId?: string | undefined;
     flowId?: string | undefined;
     instanceKey?: string | undefined;
     nodes?: Record<string, {
@@ -115,8 +115,8 @@ export declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;
@@ -142,12 +142,12 @@ export declare const updateFlowInstanceSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }>, "many">>;
         concurrency: z.ZodOptional<z.ZodNumber>;
         isCustomized: z.ZodOptional<z.ZodBoolean>;
@@ -160,8 +160,8 @@ export declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }, {
@@ -173,8 +173,8 @@ export declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }>>>;
@@ -201,8 +201,8 @@ export declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;
@@ -224,8 +224,8 @@ export declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;

package/dist/dts/integrations/accessors.d.ts

@@ -2,7 +2,7 @@ import { ElementAccessor, ElementListAccessor } from '../accessors';
 import { IntegrationLevelActionAccessor, IntegrationLevelActionsListAccessor } from '../actions';
 import { IntegrationAppApiClient } from '../api-client';
 import { Connection, ConnectionSpec } from '../connections';
-import { DataLocationListItem, DataLocationSpec, OperationListItem, OperationSpec } from '../connectors';
+import { DataCollectionListItem, DataCollectionSpec, OperationListItem, OperationSpec } from '../connectors';
 import { IntegrationLevelDataSourceAccessor, IntegrationLevelDataSourcesListAccessor } from '../data-sources';
 import { IntegrationLevelFieldMappingAccessor, IntegrationLevelFieldMappingsListAccessor } from '../field-mappings';
 import { IntegrationLevelFlowAccessor, IntegrationLevelFlowsListAccessor } from '../flows';
@@ -51,9 +51,7 @@ export declare class IntegrationAccessor extends ElementAccessor<Integration, Up
     disconnect(): Promise<void>;
     getOperations(): Promise<OperationListItem[]>;
     getOperation(key: string): Promise<OperationSpec>;
-    getDataCollections(): Promise<DataLocationListItem[]>;
-    getDataCollection(key: string): Promise<DataLocationSpec>;
-    getDataLocations(): Promise<DataLocationListItem[]>;
-    getDataLocation(key: string): Promise<DataLocationSpec>;
+    getDataCollections(): Promise<DataCollectionListItem[]>;
+    getDataCollection(key: string): Promise<DataCollectionSpec>;
 }
 export {};