@segment/actions-core 1.3.0-next.0

package/dist/esm/defaults.js

@@ -0,0 +1,11 @@
+export function defaultValues(fields) {
+    const obj = {};
+    for (const field of Object.keys(fields)) {
+        const defaultValue = fields[field].default;
+        if (typeof defaultValue !== 'undefined') {
+            obj[field] = defaultValue;
+        }
+    }
+    return obj;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVmYXVsdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLGFBQWEsQ0FBQyxNQUErQjtJQUMzRCxNQUFNLEdBQUcsR0FBb0MsRUFBRSxDQUFBO0lBRS9DLEtBQUssTUFBTSxLQUFLLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRTtRQUN2QyxNQUFNLFlBQVksR0FBSSxNQUFNLENBQUMsS0FBSyxDQUFpQixDQUFDLE9BQU8sQ0FBQTtRQUMzRCxJQUFJLE9BQU8sWUFBWSxLQUFLLFdBQVcsRUFBRTtZQUN2QyxHQUFHLENBQUMsS0FBSyxDQUFDLEdBQUcsWUFBWSxDQUFBO1NBQzFCO0tBQ0Y7SUFFRCxPQUFPLEdBQUcsQ0FBQTtBQUNaLENBQUMifQ==

package/dist/esm/destination-kit/action.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import Ajv from 'ajv';
+import { EventEmitter } from 'events';
+import { Got } from 'got';
+import { JSONLikeObject } from '../json-object';
+import { ExecuteInput, Step, StepResult, Steps } from './step';
+import type { InputField, RequestExtension } from './types';
+export declare type RequestFn<Settings, Payload> = (request: Got, data: ExecuteInput<Settings, Payload>) => any;
+export interface ActionDefinition<Settings, Payload = any> {
+    /** The unique identifier for the action, e.g. `postToChannel` */
+    /** The display title of the action */
+    title: string;
+    /** The display description of the action */
+    description: string;
+    /** Whether the action is recommended for quick setup */
+    recommended?: boolean;
+    /** An optional fql query that will be used to prepopulate the action when it is first set up */
+    defaultSubscription?: string;
+    /** Whether or not this action should be visible/configurable in the UI */
+    hidden?: boolean;
+    /**
+     * The fields used to perform the action. These fields should match what the partner API expects.
+     *
+     * This is a set of JSON Schema properties right now.
+     * We may eventually auto-generate the JSON Schema from a definition object
+     * instead of requiring devs to build and modify JSON Schema directly.
+     *
+     * Plus, JSON Schema cannot fully represent our action or field definitions
+     * without many custom keywords.
+     */
+    fields: Record<string, InputField>;
+    /**
+     * Temporary way to "register" autocomplete fields.
+     * This is likely going to change as we productionalize the data model and definition object
+     */
+    autocompleteFields?: {
+        [K in keyof Payload]?: RequestFn<Settings, Payload>;
+    };
+    /**
+     * Register fields that should be executed, cached and provided
+     * to the action's `perform` function
+     */
+    cachedFields?: {
+        [field: string]: {
+            key: (data: ExecuteInput<Settings, Payload>) => string;
+            ttl: number;
+            value: RequestFn<Settings, Payload>;
+            negative?: boolean;
+        };
+    };
+    /** The operation to perform when this action is triggered */
+    perform: RequestFn<Settings, Payload>;
+}
+export declare class Validate<Settings, Payload> extends Step<Settings, Payload> {
+    field: ExecuteInputField;
+    validate: Ajv.ValidateFunction;
+    constructor(field: ExecuteInputField, schema: object);
+    executeStep(data: ExecuteInput<Settings, Payload>): Promise<string>;
+}
+interface ExecuteAutocompleteInput<Settings, Payload> {
+    settings: Settings;
+    payload: Payload;
+    cachedFields: {
+        [key: string]: string;
+    };
+    page?: string;
+}
+declare type ExecuteInputField = 'payload' | 'settings';
+/**
+ * Action is the beginning step for all partner actions. Entrypoints always start with the
+ * MapAndValidateInput step.
+ */
+export declare class Action<Settings, Payload extends JSONLikeObject> extends EventEmitter {
+    readonly steps: Steps<Settings, Payload>;
+    private requestExtensions;
+    private autocompleteCache;
+    constructor(definition: ActionDefinition<Settings, Payload>, extendRequest?: RequestExtension<Settings, Payload>);
+    execute(data: ExecuteInput<Settings, Payload>): Promise<StepResult[]>;
+    executeAutocomplete(field: string, data: ExecuteAutocompleteInput<Settings, Payload>): any;
+    private loadDefinition;
+    private validatePayload;
+    private autocomplete;
+    private request;
+    private cachedRequest;
+}
+export {};

package/dist/esm/destination-kit/action.js

@@ -0,0 +1,209 @@
+// @ts-ignore no types
+import { AggregateAjvError } from '@segment/ajv-human-errors';
+import Ajv from 'ajv';
+import { EventEmitter } from 'events';
+import NodeCache from 'node-cache';
+import createRequestClient from '../create-request-client';
+import { get } from '../get';
+import { transform } from '../mapping-kit';
+import { fieldsToJsonSchema } from './fields-to-jsonschema';
+import { Step, Steps } from './step';
+class MapInput extends Step {
+    executeStep(data) {
+        // Transforms the initial payload (event) + action settings (from `subscriptions[0].mapping`)
+        // into input data that the action can use to talk to partner apis
+        if (data.mapping) {
+            // Technically we can't know whether or not `transform` returns the exact shape of Payload here, hence the casting
+            // It will be validated in subsequent steps
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            data.payload = transform(data.mapping, data.payload);
+        }
+        return Promise.resolve('MapInput completed');
+    }
+}
+export class Validate extends Step {
+    constructor(field, schema) {
+        super();
+        this.field = field;
+        const ajv = new Ajv({
+            // Coerce types to be a bit more liberal.
+            coerceTypes: true,
+            // Return all validation errors, not just the first.
+            allErrors: true,
+            // Include reference to schema and data in error values.
+            verbose: true,
+            // Use a more parse-able format for JSON paths.
+            jsonPointers: true
+        });
+        this.validate = ajv.compile(schema);
+    }
+    executeStep(data) {
+        if (!this.validate(data[this.field])) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            throw new AggregateAjvError(this.validate.errors);
+        }
+        return Promise.resolve('Validate completed');
+    }
+}
+/**
+ * Request handles delivering a payload to an external API. It uses the `got` library under the hood.
+ *
+ * The callback should be  able to return the raw request instead of needing to do `return response.data` etc.
+ */
+class Request extends Step {
+    constructor(extensions, requestFn) {
+        super();
+        this.extensions = extensions || [];
+        this.requestFn = requestFn;
+    }
+    async executeStep(data) {
+        if (!this.requestFn) {
+            return '';
+        }
+        const request = this.createRequestClient(data);
+        const response = await this.requestFn(request, data);
+        if (response === null) {
+            return 'TODO: null';
+        }
+        return response.body;
+    }
+    createRequestClient(data) {
+        const options = this.extensions.map((extension) => extension(data));
+        const client = createRequestClient(...options).extend({
+            hooks: {
+                beforeError: [
+                    (error) => {
+                        // @ts-ignore the type is wrong in got
+                        const { response } = error;
+                        this.emit('response', response);
+                        return error;
+                    }
+                ],
+                afterResponse: [
+                    (response) => {
+                        this.emit('response', response);
+                        return response;
+                    }
+                ]
+            }
+        });
+        return client;
+    }
+}
+// CachedRequest is like Request but cached. Next question.
+class CachedRequest extends Request {
+    constructor(extensions, config) {
+        super(extensions);
+        this.keyFn = config.key;
+        this.valueFn = config.value;
+        this.as = config.as;
+        this.negative = config.negative || false;
+        this.cache = new NodeCache({
+            stdTTL: config.ttl,
+            maxKeys: 1000
+        });
+    }
+    async executeStep(data) {
+        const k = this.keyFn(data);
+        let v = this.cache.get(k);
+        if (v !== undefined) {
+            data.cachedFields[this.as] = v;
+            return 'cache hit';
+        }
+        const request = this.createRequestClient(data);
+        try {
+            v = await this.valueFn(request, data);
+        }
+        catch (e) {
+            if (get(e, 'response.statusCode') === 404) {
+                v = undefined;
+            }
+            else {
+                throw e;
+            }
+        }
+        // Only cache if value is not negative *or* negative option is set. Negative caching is off by
+        // default because the common cases are: A) auth token generation, which should never be
+        // negative, and B) create-or-update patterns, where the resource should exist after the first
+        // negative value.
+        if ((v !== null && v !== undefined) || this.negative) {
+            this.cache.set(k, v);
+        }
+        return 'cache miss';
+    }
+}
+/**
+ * Action is the beginning step for all partner actions. Entrypoints always start with the
+ * MapAndValidateInput step.
+ */
+export class Action extends EventEmitter {
+    constructor(definition, extendRequest) {
+        super();
+        this.steps = new Steps();
+        const step = new MapInput();
+        this.steps.push(step);
+        this.autocompleteCache = {};
+        this.requestExtensions = [];
+        if (extendRequest) {
+            // This must come before we load the definition because
+            // it instantiates "steps" with whatever request extensions
+            // are defined at that moment in time
+            this.requestExtensions.push(extendRequest);
+        }
+        this.loadDefinition(definition);
+    }
+    async execute(data) {
+        const results = await this.steps.execute(data);
+        const finalResult = results[results.length - 1];
+        if (finalResult.error) {
+            throw finalResult.error;
+        }
+        return results;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    executeAutocomplete(field, data) {
+        if (!this.autocompleteCache[field]) {
+            return {
+                data: [],
+                pagination: {}
+            };
+        }
+        const step = new Request(this.requestExtensions, this.autocompleteCache[field]);
+        return step.executeStep(data);
+    }
+    loadDefinition(definition) {
+        var _a, _b;
+        if (definition.fields) {
+            this.validatePayload(definition.fields);
+        }
+        Object.entries((_a = definition.autocompleteFields) !== null && _a !== void 0 ? _a : {}).forEach(([field, callback]) => {
+            this.autocomplete(field, callback);
+        });
+        Object.entries((_b = definition.cachedFields) !== null && _b !== void 0 ? _b : {}).forEach(([field, cacheConfig]) => {
+            this.cachedRequest({
+                ...cacheConfig,
+                as: field
+            });
+        });
+        if (definition.perform) {
+            this.request(definition.perform);
+        }
+    }
+    validatePayload(fields) {
+        const step = new Validate('payload', fieldsToJsonSchema(fields));
+        this.steps.push(step);
+    }
+    autocomplete(field, callback) {
+        this.autocompleteCache[field] = callback;
+    }
+    request(requestFn) {
+        const step = new Request(this.requestExtensions, requestFn);
+        step.on('response', (response) => this.emit('response', response));
+        this.steps.push(step);
+    }
+    cachedRequest(config) {
+        const step = new CachedRequest(this.requestExtensions, config);
+        this.steps.push(step);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.js","sourceRoot":"","sources":["../../../src/destination-kit/action.ts"],"names":[],"mappings":"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"}

package/dist/esm/destination-kit/fields-to-jsonschema.d.ts

@@ -0,0 +1,4 @@
+import { JSONSchema4 } from 'json-schema';
+import type { InputField } from './types';
+export declare function fieldsToJsonSchema(fields?: Record<string, InputField>): JSONSchema4;
+export declare function jsonSchemaToFields(schema?: JSONSchema4): Record<string, InputField>;

package/dist/esm/destination-kit/fields-to-jsonschema.js

@@ -0,0 +1,33 @@
+export function fieldsToJsonSchema(fields = {}) {
+    const required = [];
+    const properties = {};
+    for (const key of Object.keys(fields)) {
+        const field = fields[key];
+        // Remove the `required` property from fields because it'll get lifted up into an array of required keys
+        properties[key] = Object.assign({}, field);
+        delete properties[key].required;
+        // Grab all the field keys with `required: true`
+        if (field.required) {
+            required.push(key);
+        }
+    }
+    return {
+        $schema: 'http://json-schema.org/schema#',
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required
+    };
+}
+export function jsonSchemaToFields(schema = {}) {
+    var _a, _b;
+    const requiredFields = (_a = schema.required) !== null && _a !== void 0 ? _a : [];
+    const properties = (_b = schema.properties) !== null && _b !== void 0 ? _b : {};
+    for (const key of Object.keys(properties)) {
+        if (requiredFields.includes(key)) {
+            properties[key].required = true;
+        }
+    }
+    return properties;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGRzLXRvLWpzb25zY2hlbWEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVzdGluYXRpb24ta2l0L2ZpZWxkcy10by1qc29uc2NoZW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxTQUFxQyxFQUFFO0lBQ3hFLE1BQU0sUUFBUSxHQUFhLEVBQUUsQ0FBQTtJQUM3QixNQUFNLFVBQVUsR0FBZ0MsRUFBRSxDQUFBO0lBRWxELEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRTtRQUNyQyxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7UUFFekIsd0dBQXdHO1FBQ3hHLFVBQVUsQ0FBQyxHQUFHLENBQUMsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxLQUFLLENBQWdCLENBQUE7UUFDekQsT0FBTyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFBO1FBRS9CLGdEQUFnRDtRQUNoRCxJQUFJLEtBQUssQ0FBQyxRQUFRLEVBQUU7WUFDbEIsUUFBUSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtTQUNuQjtLQUNGO0lBRUQsT0FBTztRQUNMLE9BQU8sRUFBRSxnQ0FBZ0M7UUFDekMsSUFBSSxFQUFFLFFBQVE7UUFDZCxvQkFBb0IsRUFBRSxLQUFLO1FBQzNCLFVBQVU7UUFDVixRQUFRO0tBQ1QsQ0FBQTtBQUNILENBQUM7QUFFRCxNQUFNLFVBQVUsa0JBQWtCLENBQUMsU0FBc0IsRUFBRTs7SUFDekQsTUFBTSxjQUFjLFNBQUksTUFBTSxDQUFDLFFBQXFCLG1DQUFJLEVBQUUsQ0FBQTtJQUMxRCxNQUFNLFVBQVUsU0FBSSxNQUFNLENBQUMsVUFBeUMsbUNBQUksRUFBRSxDQUFBO0lBRTFFLEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsRUFBRTtRQUN6QyxJQUFJLGNBQWMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDaEMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUE7U0FDaEM7S0FDRjtJQUVELE9BQU8sVUFBVSxDQUFBO0FBQ25CLENBQUMifQ==

package/dist/esm/destination-kit/index.d.ts

@@ -0,0 +1,84 @@
+import { CancelableRequest, Got, Response } from 'got';
+import { JSONSchema4 } from 'json-schema';
+import { Action, ActionDefinition } from './action';
+import { ExecuteInput, StepResult } from './step';
+import { JSONLikeObject, JSONObject } from '../json-object';
+import { SegmentEvent } from '../segment-event';
+import { fieldsToJsonSchema, jsonSchemaToFields } from './fields-to-jsonschema';
+import type { InputField, RequestExtension } from './types';
+export type { ActionDefinition, ExecuteInput };
+export { fieldsToJsonSchema, jsonSchemaToFields };
+export interface SubscriptionStats {
+    duration: number;
+    destination: string;
+    action: string;
+    subscribe: string;
+    state: string;
+    input: JSONLikeObject;
+    output: StepResult[] | null;
+}
+interface PartnerActions<Settings, Payload extends JSONLikeObject> {
+    [key: string]: Action<Settings, Payload>;
+}
+export interface DestinationDefinition<Settings = unknown> {
+    /** The name of the destination */
+    name: string;
+    /** An optional function to extend requests sent from the destination (including all actions) */
+    extendRequest?: RequestExtension<Settings>;
+    /** Optional authentication configuration */
+    authentication?: AuthenticationScheme<Settings>;
+    /** Actions */
+    actions: {
+        [key: string]: ActionDefinition<Settings>;
+    };
+    /** Subscription presets automatically applied in quick setup */
+    presets?: Subscription[];
+}
+export interface Subscription {
+    name?: string;
+    partnerAction: string;
+    subscribe: string;
+    mapping?: JSONObject;
+}
+interface TestAuthSettings<Settings> {
+    settings: Settings;
+}
+interface Authentication<Settings> {
+    scheme: 'basic' | 'custom';
+    fields: Record<string, InputField>;
+    testAuthentication: (req: Got, input: TestAuthSettings<Settings>) => CancelableRequest<Response<string>>;
+}
+export interface CustomAuthentication<Settings> extends Authentication<Settings> {
+    /** Typically used for "API Key" authentication. */
+    scheme: 'custom';
+}
+export interface BasicAuthentication<Settings> extends Authentication<Settings> {
+    scheme: 'basic';
+}
+export declare type AuthenticationScheme<Settings = any> = BasicAuthentication<Settings> | CustomAuthentication<Settings>;
+interface EventInput<Settings> {
+    readonly event: SegmentEvent;
+    readonly mapping: JSONObject;
+    readonly settings: Settings;
+}
+export declare class Destination<Settings = JSONObject> {
+    readonly definition: DestinationDefinition<Settings>;
+    readonly name: string;
+    readonly authentication?: AuthenticationScheme<Settings>;
+    readonly extendRequest?: RequestExtension<Settings>;
+    readonly actions: PartnerActions<Settings, any>;
+    readonly responses: Response[];
+    readonly settingsSchema?: JSONSchema4;
+    constructor(destination: DestinationDefinition<Settings>);
+    testAuthentication(settings: Settings): Promise<void>;
+    private partnerAction;
+    protected executeAction(actionSlug: string, { event, mapping, settings }: EventInput<Settings>): Promise<StepResult[]>;
+    private onSubscription;
+    /**
+     * Note: Until we move subscriptions upstream (into int-consumer) we've opted
+     * to have failures abort the set of subscriptions and get potentially retried by centrifuge
+     */
+    onEvent(event: SegmentEvent, settings: JSONObject, onComplete?: (stats: SubscriptionStats) => void): Promise<StepResult[]>;
+    private getSubscriptions;
+    private getDestinationSettings;
+}

package/dist/esm/destination-kit/index.js

@@ -0,0 +1,157 @@
+import { validate, parseFql } from '@segment/fab5-subscriptions';
+import { BadRequest } from 'http-errors';
+import got from 'got';
+import { Action, Validate } from './action';
+import { time, duration } from '../time';
+import { fieldsToJsonSchema, jsonSchemaToFields } from './fields-to-jsonschema';
+export { fieldsToJsonSchema, jsonSchemaToFields };
+export class Destination {
+    constructor(destination) {
+        var _a;
+        this.definition = destination;
+        this.name = destination.name;
+        this.extendRequest = destination.extendRequest;
+        this.actions = {};
+        this.authentication = destination.authentication;
+        this.responses = [];
+        // Convert to complete JSON Schema
+        if ((_a = this.authentication) === null || _a === void 0 ? void 0 : _a.fields) {
+            this.settingsSchema = fieldsToJsonSchema(this.authentication.fields);
+        }
+        for (const action of Object.keys(destination.actions)) {
+            this.partnerAction(action, destination.actions[action]);
+        }
+    }
+    async testAuthentication(settings) {
+        var _a;
+        const context = { settings, payload: {}, cachedFields: {} };
+        if (this.settingsSchema) {
+            const step = new Validate('settings', this.settingsSchema);
+            await step.executeStep(context);
+        }
+        if (!((_a = this.authentication) === null || _a === void 0 ? void 0 : _a.testAuthentication)) {
+            return;
+        }
+        let request = got.extend({
+            retry: 0,
+            timeout: 3000,
+            headers: {
+                'user-agent': undefined
+            }
+        });
+        if (typeof this.extendRequest === 'function') {
+            request = request.extend(this.extendRequest(context));
+        }
+        try {
+            await this.authentication.testAuthentication(request, { settings });
+        }
+        catch (error) {
+            throw new Error('Credentials are invalid');
+        }
+    }
+    partnerAction(slug, definition) {
+        const action = new Action(definition, this.extendRequest);
+        action.on('response', (response) => {
+            if (response) {
+                this.responses.push(response);
+            }
+        });
+        this.actions[slug] = action;
+        return this;
+    }
+    executeAction(actionSlug, { event, mapping, settings }) {
+        const action = this.actions[actionSlug];
+        if (!action) {
+            throw new BadRequest(`"${actionSlug}" is not a valid action`);
+        }
+        return action.execute({
+            cachedFields: {},
+            mapping,
+            payload: event,
+            settings
+        });
+    }
+    async onSubscription(subscription, event, settings, onComplete) {
+        const subscriptionStartedAt = time();
+        const actionSlug = subscription.partnerAction;
+        const input = {
+            event,
+            mapping: subscription.mapping || {},
+            settings
+        };
+        let state = 'pending';
+        let results = null;
+        try {
+            if (typeof subscription.subscribe !== 'string') {
+                state = 'skipped';
+                results = [{ output: 'invalid subscription' }];
+                return results;
+            }
+            const isSubscribed = validate(parseFql(subscription.subscribe), event);
+            if (!isSubscribed) {
+                state = 'skipped';
+                results = [{ output: 'not subscribed' }];
+                return results;
+            }
+            results = await this.executeAction(actionSlug, input);
+            state = 'done';
+            return results;
+        }
+        catch (error) {
+            state = 'errored';
+            results = [{ error }];
+            throw error;
+        }
+        finally {
+            const subscriptionEndedAt = time();
+            const subscriptionDuration = duration(subscriptionStartedAt, subscriptionEndedAt);
+            onComplete === null || onComplete === void 0 ? void 0 : onComplete({
+                duration: subscriptionDuration,
+                destination: this.name,
+                action: actionSlug,
+                subscribe: subscription.subscribe,
+                state,
+                input: {
+                    event: input.event,
+                    mapping: input.mapping,
+                    settings: input.settings
+                },
+                output: results
+            });
+        }
+    }
+    /**
+     * Note: Until we move subscriptions upstream (into int-consumer) we've opted
+     * to have failures abort the set of subscriptions and get potentially retried by centrifuge
+     */
+    async onEvent(event, settings, onComplete) {
+        const subscriptions = this.getSubscriptions(settings);
+        const destinationSettings = this.getDestinationSettings(settings);
+        const promises = subscriptions.map((subscription) => this.onSubscription(subscription, event, destinationSettings, onComplete));
+        const results = await Promise.all(promises);
+        return [].concat(...results);
+    }
+    getSubscriptions(settings) {
+        const { subscription, subscriptions } = settings;
+        let parsedSubscriptions;
+        // To support event tester we need to parse and validate multiple subscriptions from the settings
+        if (subscription) {
+            parsedSubscriptions = [subscription];
+        }
+        else if (typeof subscriptions === 'string') {
+            parsedSubscriptions = JSON.parse(subscriptions);
+        }
+        else if (Array.isArray(subscriptions)) {
+            parsedSubscriptions = subscriptions;
+        }
+        else {
+            parsedSubscriptions = [];
+        }
+        return parsedSubscriptions;
+    }
+    getDestinationSettings(settings) {
+        const { subcription, subscriptions, ...otherSettings } = settings;
+        return otherSettings;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVzdGluYXRpb24ta2l0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLE1BQU0sNkJBQTZCLENBQUE7QUFDaEUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUN4QyxPQUFPLEdBQXlDLE1BQU0sS0FBSyxDQUFBO0FBRTNELE9BQU8sRUFBRSxNQUFNLEVBQW9CLFFBQVEsRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUU3RCxPQUFPLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxNQUFNLFNBQVMsQ0FBQTtBQUd4QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUkvRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQTtBQXFFakQsTUFBTSxPQUFPLFdBQVc7SUFVdEIsWUFBWSxXQUE0Qzs7UUFDdEQsSUFBSSxDQUFDLFVBQVUsR0FBRyxXQUFXLENBQUE7UUFDN0IsSUFBSSxDQUFDLElBQUksR0FBRyxXQUFXLENBQUMsSUFBSSxDQUFBO1FBQzVCLElBQUksQ0FBQyxhQUFhLEdBQUcsV0FBVyxDQUFDLGFBQWEsQ0FBQTtRQUM5QyxJQUFJLENBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQTtRQUNqQixJQUFJLENBQUMsY0FBYyxHQUFHLFdBQVcsQ0FBQyxjQUFjLENBQUE7UUFDaEQsSUFBSSxDQUFDLFNBQVMsR0FBRyxFQUFFLENBQUE7UUFFbkIsa0NBQWtDO1FBQ2xDLFVBQUksSUFBSSxDQUFDLGNBQWMsMENBQUUsTUFBTSxFQUFFO1lBQy9CLElBQUksQ0FBQyxjQUFjLEdBQUcsa0JBQWtCLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQTtTQUNyRTtRQUVELEtBQUssTUFBTSxNQUFNLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLEVBQUU7WUFDckQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxNQUFNLEVBQUUsV0FBVyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFBO1NBQ3hEO0lBQ0gsQ0FBQztJQUVELEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxRQUFrQjs7UUFDekMsTUFBTSxPQUFPLEdBQStCLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUUsWUFBWSxFQUFFLEVBQUUsRUFBRSxDQUFBO1FBRXZGLElBQUksSUFBSSxDQUFDLGNBQWMsRUFBRTtZQUN2QixNQUFNLElBQUksR0FBRyxJQUFJLFFBQVEsQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFBO1lBQzFELE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQTtTQUNoQztRQUVELElBQUksUUFBQyxJQUFJLENBQUMsY0FBYywwQ0FBRSxrQkFBa0IsQ0FBQSxFQUFFO1lBQzVDLE9BQU07U0FDUDtRQUVELElBQUksT0FBTyxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUM7WUFDdkIsS0FBSyxFQUFFLENBQUM7WUFDUixPQUFPLEVBQUUsSUFBSTtZQUNiLE9BQU8sRUFBRTtnQkFDUCxZQUFZLEVBQUUsU0FBUzthQUN4QjtTQUNGLENBQUMsQ0FBQTtRQUVGLElBQUksT0FBTyxJQUFJLENBQUMsYUFBYSxLQUFLLFVBQVUsRUFBRTtZQUM1QyxPQUFPLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUE7U0FDdEQ7UUFFRCxJQUFJO1lBQ0YsTUFBTSxJQUFJLENBQUMsY0FBYyxDQUFDLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUE7U0FDcEU7UUFBQyxPQUFPLEtBQUssRUFBRTtZQUNkLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQTtTQUMzQztJQUNILENBQUM7SUFFTyxhQUFhLENBQUMsSUFBWSxFQUFFLFVBQXNDO1FBQ3hFLE1BQU0sTUFBTSxHQUFHLElBQUksTUFBTSxDQUFlLFVBQVUsRUFBRSxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUE7UUFFdkUsTUFBTSxDQUFDLEVBQUUsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxRQUFRLEVBQUUsRUFBRTtZQUNqQyxJQUFJLFFBQVEsRUFBRTtnQkFDWixJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQTthQUM5QjtRQUNILENBQUMsQ0FBQyxDQUFBO1FBRUYsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLENBQUE7UUFFM0IsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDO0lBRVMsYUFBYSxDQUNyQixVQUFrQixFQUNsQixFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUF3QjtRQUVsRCxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFBO1FBQ3ZDLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDWCxNQUFNLElBQUksVUFBVSxDQUFDLElBQUksVUFBVSx5QkFBeUIsQ0FBQyxDQUFBO1NBQzlEO1FBRUQsT0FBTyxNQUFNLENBQUMsT0FBTyxDQUFDO1lBQ3BCLFlBQVksRUFBRSxFQUFFO1lBQ2hCLE9BQU87WUFDUCxPQUFPLEVBQUUsS0FBSztZQUNkLFFBQVE7U0FDVCxDQUFDLENBQUE7SUFDSixDQUFDO0lBRU8sS0FBSyxDQUFDLGNBQWMsQ0FDMUIsWUFBMEIsRUFDMUIsS0FBbUIsRUFDbkIsUUFBa0IsRUFDbEIsVUFBK0M7UUFFL0MsTUFBTSxxQkFBcUIsR0FBRyxJQUFJLEVBQUUsQ0FBQTtRQUNwQyxNQUFNLFVBQVUsR0FBRyxZQUFZLENBQUMsYUFBYSxDQUFBO1FBQzdDLE1BQU0sS0FBSyxHQUFHO1lBQ1osS0FBSztZQUNMLE9BQU8sRUFBRSxZQUFZLENBQUMsT0FBTyxJQUFJLEVBQUU7WUFDbkMsUUFBUTtTQUNULENBQUE7UUFFRCxJQUFJLEtBQUssR0FBRyxTQUFTLENBQUE7UUFDckIsSUFBSSxPQUFPLEdBQXdCLElBQUksQ0FBQTtRQUV2QyxJQUFJO1lBQ0YsSUFBSSxPQUFPLFlBQVksQ0FBQyxTQUFTLEtBQUssUUFBUSxFQUFFO2dCQUM5QyxLQUFLLEdBQUcsU0FBUyxDQUFBO2dCQUNqQixPQUFPLEdBQUcsQ0FBQyxFQUFFLE1BQU0sRUFBRSxzQkFBc0IsRUFBRSxDQUFDLENBQUE7Z0JBQzlDLE9BQU8sT0FBTyxDQUFBO2FBQ2Y7WUFFRCxNQUFNLFlBQVksR0FBRyxRQUFRLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQTtZQUN0RSxJQUFJLENBQUMsWUFBWSxFQUFFO2dCQUNqQixLQUFLLEdBQUcsU0FBUyxDQUFBO2dCQUNqQixPQUFPLEdBQUcsQ0FBQyxFQUFFLE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSxDQUFDLENBQUE7Z0JBQ3hDLE9BQU8sT0FBTyxDQUFBO2FBQ2Y7WUFFRCxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsYUFBYSxDQUFDLFVBQVUsRUFBRSxLQUFLLENBQUMsQ0FBQTtZQUNyRCxLQUFLLEdBQUcsTUFBTSxDQUFBO1lBRWQsT0FBTyxPQUFPLENBQUE7U0FDZjtRQUFDLE9BQU8sS0FBSyxFQUFFO1lBQ2QsS0FBSyxHQUFHLFNBQVMsQ0FBQTtZQUNqQixPQUFPLEdBQUcsQ0FBQyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUE7WUFDckIsTUFBTSxLQUFLLENBQUE7U0FDWjtnQkFBUztZQUNSLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxFQUFFLENBQUE7WUFDbEMsTUFBTSxvQkFBb0IsR0FBRyxRQUFRLENBQUMscUJBQXFCLEVBQUUsbUJBQW1CLENBQUMsQ0FBQTtZQUVqRixVQUFVLGFBQVYsVUFBVSx1QkFBVixVQUFVLENBQUc7Z0JBQ1gsUUFBUSxFQUFFLG9CQUFvQjtnQkFDOUIsV0FBVyxFQUFFLElBQUksQ0FBQyxJQUFJO2dCQUN0QixNQUFNLEVBQUUsVUFBVTtnQkFDbEIsU0FBUyxFQUFFLFlBQVksQ0FBQyxTQUFTO2dCQUNqQyxLQUFLO2dCQUNMLEtBQUssRUFBRTtvQkFDTCxLQUFLLEVBQUcsS0FBSyxDQUFDLEtBQW1DO29CQUNqRCxPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU87b0JBQ3RCLFFBQVEsRUFBRyxLQUFLLENBQUMsUUFBc0M7aUJBQ3hEO2dCQUNELE1BQU0sRUFBRSxPQUFPO2FBQ2hCLEVBQUM7U0FDSDtJQUNILENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsT0FBTyxDQUNsQixLQUFtQixFQUNuQixRQUFvQixFQUNwQixVQUErQztRQUUvQyxNQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLENBQUE7UUFDckQsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLENBQUMsc0JBQXNCLENBQUMsUUFBUSxDQUFDLENBQUE7UUFFakUsTUFBTSxRQUFRLEdBQUcsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFlBQVksRUFBRSxFQUFFLENBQ2xELElBQUksQ0FBQyxjQUFjLENBQUMsWUFBWSxFQUFFLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxVQUFVLENBQUMsQ0FDMUUsQ0FBQTtRQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUUzQyxPQUFRLEVBQW1CLENBQUMsTUFBTSxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUE7SUFDaEQsQ0FBQztJQUVPLGdCQUFnQixDQUFDLFFBQW9CO1FBQzNDLE1BQU0sRUFBRSxZQUFZLEVBQUUsYUFBYSxFQUFFLEdBQUcsUUFBUSxDQUFBO1FBQ2hELElBQUksbUJBQW1CLENBQUE7UUFFdkIsaUdBQWlHO1FBQ2pHLElBQUksWUFBWSxFQUFFO1lBQ2hCLG1CQUFtQixHQUFHLENBQUMsWUFBWSxDQUFDLENBQUE7U0FDckM7YUFBTSxJQUFJLE9BQU8sYUFBYSxLQUFLLFFBQVEsRUFBRTtZQUM1QyxtQkFBbUIsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFBO1NBQ2hEO2FBQU0sSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxFQUFFO1lBQ3ZDLG1CQUFtQixHQUFHLGFBQWEsQ0FBQTtTQUNwQzthQUFNO1lBQ0wsbUJBQW1CLEdBQUcsRUFBRSxDQUFBO1NBQ3pCO1FBRUQsT0FBTyxtQkFBcUMsQ0FBQTtJQUM5QyxDQUFDO0lBRU8sc0JBQXNCLENBQUMsUUFBb0I7UUFDakQsTUFBTSxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsR0FBRyxhQUFhLEVBQUUsR0FBRyxRQUFRLENBQUE7UUFDakUsT0FBUSxhQUFxQyxDQUFBO0lBQy9DLENBQUM7Q0FDRiJ9

package/dist/esm/destination-kit/step.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { JSONObject } from '../json-object';
+export interface StepResult {
+    output?: JSONObject | string | null | undefined;
+    error?: JSONObject | null;
+}
+export interface ExecuteInput<Settings, Payload> {
+    /** The subscription mapping definition */
+    readonly mapping?: JSONObject;
+    /** The global destination settings */
+    readonly settings: Settings;
+    /** The transformed input data, based on `mapping` + `event` */
+    payload: Payload;
+    /** The ids from cached requests */
+    cachedFields: {
+        [key: string]: string;
+    };
+    /** The page used in autocomplete */
+    page?: string;
+}
+/**
+ * Step is the base class for all discrete execution steps. It handles executing the step, logging,
+ * catching errors, and returning a result object.
+ */
+export declare class Step<Settings, Payload> extends EventEmitter {
+    executeStep?(data: ExecuteInput<Settings, Payload>): Promise<string>;
+    execute(data: ExecuteInput<Settings, Payload>): Promise<StepResult>;
+}
+/**
+ * Steps is a list of one or more Step instances that can be executed in-order.
+ */
+export declare class Steps<Settings, Payload> {
+    steps: Step<Settings, Payload>[];
+    constructor();
+    push(step: Step<Settings, Payload>): void;
+    execute(data: ExecuteInput<Settings, Payload>): Promise<StepResult[]>;
+}