@membranehq/sdk 0.2.0 → 0.3.0

package/dist/bundle.js

@@ -9770,14 +9770,18 @@
 	const numberType = ZodNumber.create;
 	const booleanType = ZodBoolean.create;
 	const anyType = ZodAny.create;
+	const unknownType = ZodUnknown.create;
 	ZodNever.create;
 	const arrayType = ZodArray.create;
 	const objectType = ZodObject.create;
-	ZodUnion.create;
+	const unionType = ZodUnion.create;
 	ZodIntersection.create;
 	ZodTuple.create;
 	const recordType = ZodRecord.create;
+	const lazyType = ZodLazy.create;
+	const literalType = ZodLiteral.create;
 	const enumType = ZodEnum.create;
+	const nativeEnumType = ZodNativeEnum.create;
 	ZodPromise.create;
 	ZodOptional.create;
 	ZodNullable.create;
@@ -10808,7 +10812,7 @@
 	                });
 	            }
 	            else {
-	                throw Error('Integration.app container element not found. Was it manually removed?');
+	                throw Error('Membrane container element not found. Was it manually removed?');
 	            }
 	        }
 	        if (document.readyState === 'complete' || document.readyState === 'interactive') {
@@ -11234,6 +11238,15 @@
 	    }
 	}
 
+	var ErrorDoc;
+	(function (ErrorDoc) {
+	    ErrorDoc["AuthenticationTokenErrors"] = "authentication-token-errors";
+	    ErrorDoc["DataSourceNoCollectionSelected"] = "data-source-no-collection-selected";
+	    ErrorDoc["FlowInstanceSetupFailed"] = "flow-instance-setup-failed";
+	    ErrorDoc["FlowInstanceSetupTimeout"] = "flow-instance-setup-timeout";
+	    ErrorDoc["WebhookCannotFindUser"] = "webhook-cannot-find-user";
+	})(ErrorDoc || (ErrorDoc = {}));
+
 	var LogRecordType;
 	(function (LogRecordType) {
 	    LogRecordType["MSG"] = "message";
@@ -11244,15 +11257,6 @@
 	    LogRecordType["API"] = "api-request";
 	})(LogRecordType || (LogRecordType = {}));
 
-	var ErrorDoc;
-	(function (ErrorDoc) {
-	    ErrorDoc["AuthenticationTokenErrors"] = "authentication-token-errors";
-	    ErrorDoc["DataSourceNoCollectionSelected"] = "data-source-no-collection-selected";
-	    ErrorDoc["FlowInstanceSetupFailed"] = "flow-instance-setup-failed";
-	    ErrorDoc["FlowInstanceSetupTimeout"] = "flow-instance-setup-timeout";
-	    ErrorDoc["WebhookCannotFindUser"] = "webhook-cannot-find-user";
-	})(ErrorDoc || (ErrorDoc = {}));
-
 	var ErrorType;
 	(function (ErrorType) {
 	    ErrorType["BAD_REQUEST"] = "bad_request";
@@ -11286,6 +11290,16 @@
 	(function (ConcurrencyErrorKey) {
 	    ConcurrencyErrorKey["LOCK_TIMEOUT"] = "lock_timeout";
 	})(ConcurrencyErrorKey || (ConcurrencyErrorKey = {}));
+	const ErrorDataSchema = objectType({
+	    type: nativeEnumType(ErrorType).optional(),
+	    key: stringType().optional(),
+	    message: stringType(),
+	    data: anyType().optional(),
+	    doc: nativeEnumType(ErrorDoc).optional(),
+	    stack: anyType().optional(),
+	    causedByError: lazyType(() => ErrorDataSchema).optional(),
+	    logs: arrayType(anyType()).optional(),
+	});
 	class ErrorData {
 	    constructor(arg) {
 	        if (arg instanceof Error) {
@@ -12194,6 +12208,41 @@
 	    DataLocatorStepType["ARRAY_ITEM"] = "array_item";
 	})(DataLocatorStepType || (DataLocatorStepType = {}));
 
+	const DataSchemaSchema = lazyType(() => objectType({
+	    title: stringType().optional(),
+	    description: stringType().optional(),
+	    type: unionType([stringType(), arrayType(stringType())]).optional(),
+	    format: stringType().optional(),
+	    properties: recordType(DataSchemaSchema).optional(),
+	    items: DataSchemaSchema.optional(),
+	    additionalProperties: unionType([booleanType(), DataSchemaSchema]).optional(),
+	    enum: arrayType(stringType()).optional(),
+	    referenceRecords: arrayType(anyType()).optional(),
+	    referenceCollection: objectType({
+	        key: anyType(),
+	        parameters: recordType(anyType()).optional(),
+	    })
+	        .optional(),
+	    referenceUdm: stringType().optional(),
+	    default: anyType().optional(),
+	    allowCustom: booleanType().optional(),
+	    $ref: stringType().optional(),
+	    required: arrayType(stringType()).optional(),
+	    minLength: numberType().optional(),
+	    maxLength: numberType().optional(),
+	    minimum: numberType().optional(),
+	    maximum: numberType().optional(),
+	    maxItems: numberType().optional(),
+	    readOnly: booleanType().optional(),
+	    writeOnly: booleanType().optional(),
+	    examples: arrayType(anyType()).optional(),
+	    anyOf: arrayType(DataSchemaSchema).optional(),
+	    isImplied: booleanType().optional(),
+	    isSensitive: booleanType().optional(),
+	    referenceCollectionPath: stringType().optional(),
+	    referenceCollectionUri: stringType().optional(),
+	}));
+
 	var ConnectorMethodImplementationType;
 	(function (ConnectorMethodImplementationType) {
 	    ConnectorMethodImplementationType["mapping"] = "mapping";
@@ -12483,7 +12532,7 @@
 	    [UDM.TIMEOFF_REQUESTS]: udm$1,
 	});
 
-	const DataLocationMethodImplementationTypes = [
+	[
 	    ConnectorMethodImplementationType.operationMapping,
 	    ConnectorMethodImplementationType.restApiMapping,
 	    ConnectorMethodImplementationType.graphqlApiMapping,
@@ -12593,23 +12642,70 @@
 	    ],
 	});
 
-	({
-	    supportedImplementationTypes: [ConnectorMethodImplementationType.mapping, ...DataLocationMethodImplementationTypes],
+	const ApiRequestSpecSchema = objectType({
+	    path: unknownType(),
+	    method: unknownType(),
 	});
-
-	({
-	    supportedImplementationTypes: [ConnectorMethodImplementationType.javascript],
+	const DataCollectionMethodSpecSchema = objectType({
+	    apiRequests: arrayType(ApiRequestSpecSchema).optional(),
+	});
+	const DataCollectionListSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    filterFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionSearchSpecSchema = DataCollectionMethodSpecSchema.extend({});
+	const DataCollectionMatchSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    fields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionFindByIdSpecSchema = DataCollectionMethodSpecSchema.extend({});
+	const DataCollectionCreateSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    fields: arrayType(stringType()).optional(),
+	    requiredFields: arrayType(stringType()).optional(),
+	    excludedFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionUpdateSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    fields: arrayType(stringType()).optional(),
+	    excludedFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionDeleteSpecSchema = DataCollectionMethodSpecSchema.extend({});
+	const DataCollectionFindSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    queryFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionEventTypeSpecSchema = objectType({
+	    type: enumType(['push', 'pull']),
+	    isFullScan: booleanType().optional(),
+	    isIdOnly: booleanType().optional(),
+	});
+	const DataCollectionEventsSpecSchema = objectType({
+	    created: DataCollectionEventTypeSpecSchema.optional(),
+	    updated: DataCollectionEventTypeSpecSchema.optional(),
+	    deleted: DataCollectionEventTypeSpecSchema.optional(),
+	    all: DataCollectionEventTypeSpecSchema.optional(),
+	})
+	    .catchall(DataCollectionEventTypeSpecSchema);
+	const DataCollectionUdmSpecSchema = objectType({
+	    fields: arrayType(stringType()).optional(),
+	    extract: recordType(anyType()).optional(),
+	    parse: recordType(anyType()).optional(),
+	});
+	const DataCollectionUdmsSpecSchema = recordType(DataCollectionUdmSpecSchema);
+	objectType({
+	    type: literalType('collection'),
+	    key: stringType().optional(),
+	    name: stringType(),
+	    parametersSchema: DataSchemaSchema.optional(),
+	    fieldsSchema: DataSchemaSchema.optional(),
+	    list: DataCollectionListSpecSchema.optional(),
+	    search: DataCollectionSearchSpecSchema.optional(),
+	    match: DataCollectionMatchSpecSchema.optional(),
+	    findById: DataCollectionFindByIdSpecSchema.optional(),
+	    create: DataCollectionCreateSpecSchema.optional(),
+	    update: DataCollectionUpdateSpecSchema.optional(),
+	    delete: DataCollectionDeleteSpecSchema.optional(),
+	    events: DataCollectionEventsSpecSchema.optional(),
+	    customFields: booleanType().optional(),
+	    udm: DataCollectionUdmsSpecSchema.optional(),
+	    find: DataCollectionFindSpecSchema.optional(),
 	});
-
-	var DataLocationType;
-	(function (DataLocationType) {
-	    DataLocationType["directory"] = "directory";
-	    DataLocationType["collection"] = "collection";
-	})(DataLocationType || (DataLocationType = {}));
-	var DataDirectoryOperation;
-	(function (DataDirectoryOperation) {
-	    DataDirectoryOperation["list"] = "list";
-	})(DataDirectoryOperation || (DataDirectoryOperation = {}));
 
 	var urlJoin$1 = {exports: {}};
 
@@ -20606,7 +20702,7 @@
 	    ActionRunLogStatus["ERROR"] = "error";
 	})(ActionRunLogStatus || (ActionRunLogStatus = {}));
 
-	/*! Axios v1.11.0 Copyright (c) 2025 Matt Zabriskie and contributors */
+	/*! Axios v1.10.0 Copyright (c) 2025 Matt Zabriskie and contributors */
 	function bind(fn, thisArg) {
 	  return function wrap() {
 	    return fn.apply(thisArg, arguments);
@@ -20747,27 +20843,6 @@
 	  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);
 	};
 
-	/**
-	 * Determine if a value is an empty object (safely handles Buffers)
-	 *
-	 * @param {*} val The value to test
-	 *
-	 * @returns {boolean} True if value is an empty object, otherwise false
-	 */
-	const isEmptyObject = (val) => {
-	  // Early return for non-objects or Buffers to prevent RangeError
-	  if (!isObject(val) || isBuffer(val)) {
-	    return false;
-	  }
-	  
-	  try {
-	    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
-	  } catch (e) {
-	    // Fallback for any other objects that might cause RangeError with Object.keys()
-	    return false;
-	  }
-	};
-
 	/**
 	 * Determine if a value is a Date
 	 *
@@ -20890,11 +20965,6 @@
 	      fn.call(null, obj[i], i, obj);
 	    }
 	  } else {
-	    // Buffer check
-	    if (isBuffer(obj)) {
-	      return;
-	    }
-
 	    // Iterate over object keys
 	    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
 	    const len = keys.length;
@@ -20908,10 +20978,6 @@
 	}
 
 	function findKey(obj, key) {
-	  if (isBuffer(obj)){
-	    return null;
-	  }
-
 	  key = key.toLowerCase();
 	  const keys = Object.keys(obj);
 	  let i = keys.length;
@@ -21265,11 +21331,6 @@
 	        return;
 	      }
 
-	      //Buffer check
-	      if (isBuffer(source)) {
-	        return source;
-	      }
-
 	      if(!('toJSON' in source)) {
 	        stack[i] = source;
 	        const target = isArray(source) ? [] : {};
@@ -21341,7 +21402,6 @@
 	  isBoolean,
 	  isObject,
 	  isPlainObject,
-	  isEmptyObject,
 	  isReadableStream,
 	  isRequest,
 	  isResponse,
@@ -21973,7 +22033,7 @@
 	};
 
 	function toURLEncodedForm(data, options) {
-	  return toFormData$1(data, new platform.classes.URLSearchParams(), {
+	  return toFormData$1(data, new platform.classes.URLSearchParams(), Object.assign({
 	    visitor: function(value, key, path, helpers) {
 	      if (platform.isNode && utils$1.isBuffer(value)) {
 	        this.append(key, value.toString('base64'));
@@ -21981,9 +22041,8 @@
 	      }
 
 	      return helpers.defaultVisitor.apply(this, arguments);
-	    },
-	    ...options
-	  });
+	    }
+	  }, options));
 	}
 
 	/**
@@ -22736,7 +22795,7 @@
 	      clearTimeout(timer);
 	      timer = null;
 	    }
-	    fn(...args);
+	    fn.apply(null, args);
 	  };
 
 	  const throttled = (...args) => {
@@ -22992,7 +23051,7 @@
 	    headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
 	  };
 
-	  utils$1.forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {
+	  utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
 	    const merge = mergeMap[prop] || mergeDeepProperties;
 	    const configValue = merge(config1[prop], config2[prop], prop);
 	    (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
@@ -23733,7 +23792,7 @@
 	  });
 	}
 
-	const VERSION$1 = "1.11.0";
+	const VERSION$1 = "1.10.0";
 
 	const validators$1 = {};
 
@@ -23972,8 +24031,8 @@
 
 	    if (!synchronousRequestInterceptors) {
 	      const chain = [dispatchRequest.bind(this), undefined];
-	      chain.unshift(...requestInterceptorChain);
-	      chain.push(...responseInterceptorChain);
+	      chain.unshift.apply(chain, requestInterceptorChain);
+	      chain.push.apply(chain, responseInterceptorChain);
 	      len = chain.length;
 
 	      promise = Promise.resolve(config);
@@ -24617,7 +24676,7 @@
 	    ConnectionType["REDIRECT"] = "redirect";
 	})(ConnectionType || (ConnectionType = {}));
 	async function createOrUpdateConnection(options) {
-	    const { connectionId, integrationId, name, parameters, allowMultipleConnections, authOptionKey, connectorSpec, apiUri, token, redirectUri, } = options !== null && options !== void 0 ? options : {};
+	    const { connectionId, integrationId, name, parameters, connectorParameters, allowMultipleConnections, authOptionKey, connectorSpec, apiUri, token, redirectUri, } = options !== null && options !== void 0 ? options : {};
 	    const connectionType = getConnectionType({
 	        connectorSpec,
 	        authOptionKey,
@@ -24631,6 +24690,7 @@
 	        const payload = {
 	            token,
 	            connectionParameters: parameters,
+	            connectorParameters,
 	            name,
 	            authOptionKey,
 	            allowMultipleConnections,
@@ -24916,6 +24976,49 @@
 	    FlowNodeRunStatus["FAILED"] = "failed";
 	    FlowNodeRunStatus["SKIPPED"] = "skipped";
 	})(FlowNodeRunStatus || (FlowNodeRunStatus = {}));
+	const UpstreamFlowNodeRunSchema = objectType({
+	    nodeKey: stringType(),
+	    runId: stringType(),
+	    outputId: stringType(),
+	});
+	const DownstreamFlowNodeRunSchema = objectType({
+	    runId: stringType(),
+	    nodeKey: stringType(),
+	});
+	const FlowNodeRunParametersSchema = objectType({
+	    id: stringType(),
+	    upstreamRuns: arrayType(UpstreamFlowNodeRunSchema),
+	    input: anyType(),
+	});
+	const FlowNodeRunOutputSchema = objectType({
+	    id: stringType(),
+	    data: stringType(),
+	    downstreamRuns: arrayType(DownstreamFlowNodeRunSchema),
+	});
+	const FlowNodeRunResultSchema = objectType({
+	    status: nativeEnumType(FlowNodeRunStatus),
+	    logs: arrayType(anyType()),
+	    outputs: arrayType(FlowNodeRunOutputSchema),
+	    errors: arrayType(ErrorDataSchema),
+	});
+	FlowNodeRunParametersSchema.merge(FlowNodeRunResultSchema);
+	objectType({
+	    id: stringType(),
+	    data: stringType(),
+	});
+	const FlowNodeRunOutputMetadataSchema = objectType({
+	    id: stringType(),
+	    downstreamRuns: arrayType(DownstreamFlowNodeRunSchema),
+	});
+	objectType({
+	    id: stringType(),
+	    upstreamRuns: arrayType(UpstreamFlowNodeRunSchema),
+	    input: anyType(),
+	    status: nativeEnumType(FlowNodeRunStatus),
+	    logs: arrayType(anyType()),
+	    outputs: arrayType(FlowNodeRunOutputMetadataSchema),
+	    errors: arrayType(ErrorDataSchema),
+	});
 
 	class FlowRunsAccessor {
 	    constructor(client) {
@@ -25543,10 +25646,7 @@
 	    dataCollection(key, parameters) {
 	        return new ConnectionDataCollectionAccessor(this.client, this, key, parameters);
 	    }
-	    dataDirectory(key, parameters) {
-	        return new ConnectionDataDirectoryAccessor(this.client, this, key, parameters);
-	    }
-	    async reconnect({ parameters, authOptionKey, } = {}) {
+	    async reconnect({ parameters, authOptionKey, connectorParameters, } = {}) {
 	        const connection = await this.get();
 	        const connectorSpec = await this.client.get(`/integrations/${connection.integrationId}/connector-spec`);
 	        return createOrUpdateConnection({
@@ -25554,6 +25654,7 @@
 	            connectorSpec,
 	            parameters,
 	            authOptionKey,
+	            connectorParameters,
 	            apiUri: this.client.apiUri,
 	            token: await this.client.getToken(),
 	        });
@@ -25588,17 +25689,6 @@
 	        return this.client.post(this.connectionAccessor.getPath(`operations/${this.key}/run`), request);
 	    }
 	}
-	class ConnectionDataDirectoryAccessor {
-	    constructor(client, connectionAccessor, key, parameters) {
-	        this.client = client;
-	        this.connectionAccessor = connectionAccessor;
-	        this.key = key;
-	        this.parameters = parameters;
-	    }
-	    async list(request) {
-	        return this.client.post(this.connectionAccessor.getPath(`data/${this.key}/list`, this.parameters), request);
-	    }
-	}
 	class ConnectionDataCollectionAccessor {
 	    constructor(client, connectionAccessor, key, parameters) {
 	        this.client = client;
@@ -25826,10 +25916,11 @@
 	            onClose,
 	        });
 	    }
-	    async openNewConnection({ allowMultipleConnections, name } = {}) {
+	    async openNewConnection({ allowMultipleConnections, name, connectorParameters, } = {}) {
 	        const uri = await this.client.getEmbedUri(`integrations/${this.integrationSelector}/connect`, {
 	            allowMultipleConnections: allowMultipleConnections ? '1' : '',
 	            name,
+	            connectorParameters: connectorParameters ? JSON.stringify(connectorParameters) : undefined,
 	        });
 	        return new Promise((resolve) => {
 	            return openIframe(uri, {
@@ -25838,7 +25929,7 @@
 	            });
 	        });
 	    }
-	    async connect({ name, parameters, authOptionKey, allowMultipleConnections, redirectUri, sameWindow, } = {}) {
+	    async connect({ name, parameters, connectorParameters, authOptionKey, allowMultipleConnections, redirectUri, sameWindow, } = {}) {
 	        const integration = await this.get();
 	        const connectorSpec = await this.getConnectorSpec();
 	        return createOrUpdateConnection({
@@ -25846,6 +25937,7 @@
 	            connectorSpec,
 	            name,
 	            parameters,
+	            connectorParameters,
 	            authOptionKey,
 	            allowMultipleConnections,
 	            apiUri: this.client.apiUri,
@@ -25871,12 +25963,6 @@
 	    async getDataCollection(key) {
 	        return this.client.get(this.getPath(`data/${key}`));
 	    }
-	    async getDataLocations() {
-	        return this.client.get(this.getPath('data'));
-	    }
-	    async getDataLocation(key) {
-	        return this.client.get(this.getPath(`data/${key}`));
-	    }
 	}
 
 	var ScenarioTemplateCategory;