medusa-plugin-automation 0.1.0

package/.medusa/server/src/api/webhooks/[id]/route.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const crypto_1 = require("crypto");
+const automation_1 = require("../../../modules/automation");
+const automation_trigger_1 = require("../../../modules/automation/models/automation-trigger");
+const automation_receipt_1 = require("../../../modules/automation/models/automation-receipt");
+const dispatch_1 = require("../../../lib/dispatch");
+const POST = async (req, res) => {
+    const automationService = req.scope.resolve(automation_1.AUTOMATION_MODULE);
+    const { id } = req.params;
+    // Enforce configurable payload size limit before doing any DB work
+    const maxBytes = (0, dispatch_1.parseMaxBytes)(automationService.getOptions().maxPayloadSize);
+    const bodyBytes = Buffer.byteLength(JSON.stringify(req.body ?? ''));
+    if (bodyBytes > maxBytes) {
+        return res.status(413).json({ error: 'Payload too large' });
+    }
+    const [trigger] = await automationService.listAutomationTriggers({ id }, { take: 1 });
+    if (!trigger ||
+        trigger.trigger_type !== automation_trigger_1.AutomationTriggerType.INCOMING_WEBHOOK ||
+        !trigger.is_active) {
+        return res.status(404).json({ error: 'Webhook not found or not active' });
+    }
+    // Verify HMAC-SHA256 signature if a signing key is configured
+    if (trigger.trigger_signing_key) {
+        const signature = req.headers['x-webhook-signature'];
+        if (!signature) {
+            return res.status(401).json({ error: 'Missing x-webhook-signature header' });
+        }
+        const expected = (0, crypto_1.createHmac)('sha256', trigger.trigger_signing_key)
+            .update(JSON.stringify(req.body))
+            .digest('hex');
+        try {
+            const sigBuffer = Buffer.from(signature);
+            const expectedBuffer = Buffer.from(expected);
+            if (sigBuffer.length !== expectedBuffer.length ||
+                !(0, crypto_1.timingSafeEqual)(sigBuffer, expectedBuffer)) {
+                return res.status(401).json({ error: 'Invalid signature' });
+            }
+        }
+        catch {
+            return res.status(401).json({ error: 'Invalid signature' });
+        }
+    }
+    const incomingPayload = req.body;
+    // Log the receipt if enabled for this trigger
+    if (trigger.log_incoming) {
+        const requestIp = req.headers['x-forwarded-for']?.split(',')[0]?.trim() ??
+            req.socket?.remoteAddress ??
+            null;
+        await automationService.createAutomationReceipts({
+            trigger_id: trigger.id,
+            request_ip: requestIp,
+            payload: (0, automation_receipt_1.redactPayload)(incomingPayload)
+        });
+    }
+    // Load all active actions for this trigger
+    const [actions] = await automationService.listAndCountAutomationActions({
+        trigger_id: trigger.id,
+        is_active: true
+    });
+    if (actions.length === 0) {
+        return res.status(200).json({ received: true, actions_executed: 0 });
+    }
+    // Incoming webhooks don't sign outgoing payloads and don't do query augmentation
+    const opts = {
+        signOutgoing: false,
+        maxWorkflowIterations: automationService.getOptions().maxWorkflowIterations
+    };
+    const results = await Promise.allSettled(actions.map(action => (0, dispatch_1.dispatchAndRecord)(req.scope, action, incomingPayload, `incoming_webhook:${action.name}`, opts)));
+    const anyFailed = results.some(r => r.status === 'rejected' || (r.status === 'fulfilled' && r.value.status === 'failed'));
+    res.status(anyFailed ? 207 : 200).json({
+        received: true,
+        actions_executed: actions.length
+    });
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/lib/dispatch.d.ts

@@ -0,0 +1,43 @@
+import { MedusaContainer } from '@medusajs/framework/types';
+import { FieldMapping, StaticValue } from '../modules/automation/models/automation-action';
+import { AutomationDeliveryStatus } from '../modules/automation/models/automation-delivery';
+import { AutomationService } from '../modules/automation/service';
+export declare function getNestedValue(obj: Record<string, unknown>, path: string): unknown;
+export declare function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void;
+export declare function applyMappings(source: Record<string, unknown>, mappings: FieldMapping[]): Record<string, unknown>;
+export declare function applyMappingsWithCoercion(source: Record<string, unknown>, mappings: FieldMapping[]): Record<string, unknown>;
+export declare function applyStaticValues(base: Record<string, unknown>, statics: StaticValue[]): Record<string, unknown>;
+export declare function flattenForQueryParams(obj: Record<string, unknown>, prefix?: string): Record<string, string>;
+export declare function resolveEventRefs(filters: unknown, eventData: Record<string, unknown>): Record<string, unknown>;
+type FanoutMapping = {
+    arrayPath: string;
+    itemPath: string;
+    targetKey: string;
+};
+export declare function parseFanoutMappings(mappings: FieldMapping[]): FanoutMapping[];
+export declare function buildIterationPayload(item: unknown, fanout: FanoutMapping[], direct: FieldMapping[], sourceData: Record<string, unknown>): Record<string, unknown>;
+export declare function parseMaxBytes(value: string | number | undefined): number;
+export declare function augmentWithQuery(container: MedusaContainer, automationService: AutomationService, actionId: string, eventData: Record<string, unknown>): Promise<Record<string, unknown>>;
+export type DispatchResult = {
+    status: AutomationDeliveryStatus;
+    responseStatus: number | null;
+    responseBody: string | null;
+    errorMessage: string | null;
+};
+export type DispatchOptions = {
+    /** Whether to sign outgoing webhooks (subscriber: yes, incoming webhook handler: no) */
+    signOutgoing?: boolean;
+    /** Max workflow fan-out iterations (from plugin options) */
+    maxWorkflowIterations?: number;
+};
+/**
+ * Execute a single action's pipeline: mapping → HTTP/workflow → result.
+ * Does NOT record a delivery — the caller is responsible for that.
+ */
+export declare function dispatchAction(container: MedusaContainer, action: any, sourceData: Record<string, unknown>, opts?: DispatchOptions): Promise<DispatchResult>;
+/**
+ * Execute an action and record the delivery.
+ * This is the main entry point used by the subscriber and webhook handler.
+ */
+export declare function dispatchAndRecord(container: MedusaContainer, action: any, sourceData: Record<string, unknown>, eventName: string, opts?: DispatchOptions): Promise<DispatchResult>;
+export {};

package/.medusa/server/src/lib/dispatch.js

@@ -0,0 +1,400 @@
+"use strict";
+// Shared action execution pipeline — used by the subscriber, webhook handler,
+// and MCP tools.  Each caller resolves the action + payload, this module
+// handles mapping, HTTP calls / workflow execution, signing, and delivery recording.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNestedValue = getNestedValue;
+exports.setNestedValue = setNestedValue;
+exports.applyMappings = applyMappings;
+exports.applyMappingsWithCoercion = applyMappingsWithCoercion;
+exports.applyStaticValues = applyStaticValues;
+exports.flattenForQueryParams = flattenForQueryParams;
+exports.resolveEventRefs = resolveEventRefs;
+exports.parseFanoutMappings = parseFanoutMappings;
+exports.buildIterationPayload = buildIterationPayload;
+exports.parseMaxBytes = parseMaxBytes;
+exports.augmentWithQuery = augmentWithQuery;
+exports.dispatchAction = dispatchAction;
+exports.dispatchAndRecord = dispatchAndRecord;
+const crypto_1 = require("crypto");
+const coreFlows = __importStar(require("@medusajs/medusa/core-flows"));
+const utils_1 = require("@medusajs/framework/utils");
+const automation_action_1 = require("../modules/automation/models/automation-action");
+const automation_delivery_1 = require("../modules/automation/models/automation-delivery");
+const automation_1 = require("../modules/automation");
+// ─── Mapping helpers ──────────────────────────────────────────────────────────
+function getNestedValue(obj, path) {
+    return path.split('.').reduce((curr, key) => {
+        if (curr !== null && typeof curr === 'object') {
+            return curr[key];
+        }
+        return undefined;
+    }, obj);
+}
+function setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    let curr = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!(keys[i] in curr) || typeof curr[keys[i]] !== 'object') {
+            curr[keys[i]] = {};
+        }
+        curr = curr[keys[i]];
+    }
+    curr[keys[keys.length - 1]] = value;
+}
+function applyMappings(source, mappings) {
+    if (!mappings || mappings.length === 0)
+        return source;
+    const result = {};
+    for (const mapping of mappings) {
+        const value = getNestedValue(source, mapping.source_path);
+        if (value !== undefined)
+            setNestedValue(result, mapping.target_key, value);
+    }
+    return result;
+}
+function applyMappingsWithCoercion(source, mappings) {
+    if (!mappings || mappings.length === 0)
+        return source;
+    const result = {};
+    for (const mapping of mappings) {
+        let value = getNestedValue(source, mapping.source_path);
+        if (value === undefined)
+            continue;
+        let targetKey = mapping.target_key;
+        if (targetKey.endsWith('[]')) {
+            targetKey = targetKey.slice(0, -2);
+            if (!Array.isArray(value))
+                value = [value];
+        }
+        setNestedValue(result, targetKey, value);
+    }
+    return result;
+}
+function applyStaticValues(base, statics) {
+    if (!statics || statics.length === 0)
+        return base;
+    const result = { ...base };
+    for (const s of statics) {
+        if (s.key)
+            setNestedValue(result, s.key, s.value);
+    }
+    return result;
+}
+function flattenForQueryParams(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (value !== null &&
+            value !== undefined &&
+            typeof value === 'object' &&
+            !Array.isArray(value)) {
+            Object.assign(result, flattenForQueryParams(value, fullKey));
+        }
+        else if (value !== null && value !== undefined) {
+            result[fullKey] = String(value);
+        }
+    }
+    return result;
+}
+// ─── Query helpers ────────────────────────────────────────────────────────────
+function resolveEventRefs(filters, eventData) {
+    function resolve(val) {
+        if (typeof val === 'string' && val.startsWith('$event.')) {
+            return getNestedValue(eventData, val.slice(7)) ?? val;
+        }
+        if (Array.isArray(val))
+            return val.map(resolve);
+        if (val !== null && typeof val === 'object') {
+            return Object.fromEntries(Object.entries(val).map(([k, v]) => [k, resolve(v)]));
+        }
+        return val;
+    }
+    if (!filters || typeof filters !== 'object')
+        return {};
+    return resolve(filters);
+}
+function parseFanoutMappings(mappings) {
+    const result = [];
+    for (const m of mappings) {
+        const match = m.source_path.match(/^(.+?)\[\]\.?(.*)$/);
+        if (match) {
+            result.push({ arrayPath: match[1], itemPath: match[2], targetKey: m.target_key });
+        }
+    }
+    return result;
+}
+function buildIterationPayload(item, fanout, direct, sourceData) {
+    const result = {};
+    for (const m of direct) {
+        let value = getNestedValue(sourceData, m.source_path);
+        if (value === undefined)
+            continue;
+        let targetKey = m.target_key;
+        if (targetKey.endsWith('[]')) {
+            targetKey = targetKey.slice(0, -2);
+            if (!Array.isArray(value))
+                value = [value];
+        }
+        setNestedValue(result, targetKey, value);
+    }
+    for (const f of fanout) {
+        let value = f.itemPath ? getNestedValue(item, f.itemPath) : item;
+        if (value === undefined)
+            continue;
+        let targetKey = f.targetKey;
+        if (targetKey.endsWith('[]')) {
+            targetKey = targetKey.slice(0, -2);
+            if (!Array.isArray(value))
+                value = [value];
+        }
+        setNestedValue(result, targetKey, value);
+    }
+    return result;
+}
+// ─── Payload size helper ──────────────────────────────────────────────────────
+function parseMaxBytes(value) {
+    if (value === undefined)
+        return 100 * 1024;
+    if (typeof value === 'number')
+        return value;
+    const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(kb|mb|gb|b)?$/i);
+    if (!match)
+        return 100 * 1024;
+    const num = parseFloat(match[1]);
+    const unit = (match[2] ?? 'b').toLowerCase();
+    const multipliers = { b: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3 };
+    return Math.floor(num * (multipliers[unit] ?? 1));
+}
+// ─── Query augmentation ───────────────────────────────────────────────────────
+async function augmentWithQuery(container, automationService, actionId, eventData) {
+    const sourceData = { ...eventData };
+    const queryConfigs = await automationService.listAutomationQueries({ action_id: actionId }, { take: 1 });
+    const queryConfig = queryConfigs[0] ?? null;
+    if (queryConfig) {
+        try {
+            const medusaQuery = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+            const resolvedFilters = resolveEventRefs(queryConfig.filters, eventData);
+            const { data } = await medusaQuery.graph({
+                entity: queryConfig.entity_name,
+                fields: queryConfig.fields ?? ['*'],
+                filters: resolvedFilters,
+                pagination: { take: Math.min(queryConfig.limit ?? 10, 100) }
+            });
+            sourceData[queryConfig.entity_name] = data[0] ?? null;
+            sourceData[`${queryConfig.entity_name}_list`] = data;
+        }
+        catch (err) {
+            sourceData._query_error = err instanceof Error ? err.message : String(err);
+        }
+    }
+    return sourceData;
+}
+/**
+ * Execute a single action's pipeline: mapping → HTTP/workflow → result.
+ * Does NOT record a delivery — the caller is responsible for that.
+ */
+async function dispatchAction(container, action, sourceData, opts = {}) {
+    const automationService = container.resolve(automation_1.AUTOMATION_MODULE);
+    const mappings = Array.isArray(action.field_mappings)
+        ? action.field_mappings
+        : [];
+    const statics = Array.isArray(action.static_values)
+        ? action.static_values
+        : [];
+    let status = automation_delivery_1.AutomationDeliveryStatus.PENDING;
+    let responseStatus = null;
+    let responseBody = null;
+    let errorMessage = null;
+    try {
+        if (action.action_type === automation_action_1.AutomationActionType.OUTGOING_WEBHOOK) {
+            if (!action.target_url)
+                throw new Error('No target URL configured');
+            const dynamicPayload = applyMappings(sourceData, mappings);
+            const mappedPayload = applyStaticValues(dynamicPayload, statics);
+            const bodyStr = JSON.stringify(mappedPayload);
+            const headers = { 'Content-Type': 'application/json' };
+            if (Array.isArray(action.target_headers)) {
+                for (const h of action.target_headers) {
+                    if (h.key)
+                        headers[h.key] = h.value;
+                }
+            }
+            if (opts.signOutgoing && action.signing_secret_id) {
+                const [secret] = await automationService.listAutomationSecrets({ id: action.signing_secret_id }, { take: 1 });
+                if (secret?.secret) {
+                    const sig = (0, crypto_1.createHmac)('sha256', secret.secret)
+                        .update(bodyStr)
+                        .digest('hex');
+                    headers['x-webhook-signature'] = sig;
+                }
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const response = await fetch(action.target_url, {
+                method: 'POST',
+                headers,
+                body: bodyStr,
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            responseStatus = response.status;
+            responseBody = await response.text().catch(() => null);
+            status = response.ok
+                ? automation_delivery_1.AutomationDeliveryStatus.SUCCESS
+                : automation_delivery_1.AutomationDeliveryStatus.FAILED;
+            if (!response.ok) {
+                errorMessage = `HTTP ${response.status}: ${responseBody?.slice(0, 200) ?? 'no body'}`;
+            }
+        }
+        else if (action.action_type === 'outgoing_request') {
+            if (!action.target_url)
+                throw new Error('No target URL configured');
+            const method = action.request_method || 'POST';
+            const dynamicPayload = applyMappings(sourceData, mappings);
+            const mappedPayload = applyStaticValues(dynamicPayload, statics);
+            const headers = {};
+            if (Array.isArray(action.target_headers)) {
+                for (const h of action.target_headers) {
+                    if (h.key)
+                        headers[h.key] = h.value;
+                }
+            }
+            let requestUrl = action.target_url;
+            let requestBody;
+            if (method === 'GET' || method === 'DELETE') {
+                const flat = flattenForQueryParams(mappedPayload);
+                const qs = new URLSearchParams(flat).toString();
+                if (qs)
+                    requestUrl = `${action.target_url}?${qs}`;
+            }
+            else {
+                headers['Content-Type'] = 'application/json';
+                requestBody = JSON.stringify(mappedPayload);
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const response = await fetch(requestUrl, {
+                method,
+                headers,
+                body: requestBody,
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            responseStatus = response.status;
+            responseBody = await response.text().catch(() => null);
+            status = response.ok
+                ? automation_delivery_1.AutomationDeliveryStatus.SUCCESS
+                : automation_delivery_1.AutomationDeliveryStatus.FAILED;
+            if (!response.ok) {
+                errorMessage = `HTTP ${response.status}: ${responseBody?.slice(0, 200) ?? 'no body'}`;
+            }
+        }
+        else if (action.action_type === automation_action_1.AutomationActionType.MEDUSA_WORKFLOW) {
+            if (!action.medusa_workflow)
+                throw new Error('No workflow configured');
+            const workflowFn = coreFlows[action.medusa_workflow];
+            if (typeof workflowFn !== 'function') {
+                throw new Error(`Unknown workflow: "${action.medusa_workflow}"`);
+            }
+            const run = workflowFn(container).run;
+            const fanoutMappings = parseFanoutMappings(mappings);
+            if (fanoutMappings.length > 0) {
+                const arrayPath = fanoutMappings[0].arrayPath;
+                const raw = getNestedValue(sourceData, arrayPath);
+                const items = Array.isArray(raw)
+                    ? raw
+                    : raw !== undefined && raw !== null
+                        ? [raw]
+                        : [];
+                const maxIter = opts.maxWorkflowIterations;
+                const cap = maxIter === 0 ? undefined : (maxIter ?? 50);
+                const cappedItems = cap !== undefined ? items.slice(0, cap) : items;
+                const directMappings = mappings.filter(m => !m.source_path.includes('[]'));
+                const iterErrors = [];
+                for (const item of cappedItems) {
+                    const payload = buildIterationPayload(item, fanoutMappings, directMappings, sourceData);
+                    const finalPayload = applyStaticValues(payload, statics);
+                    try {
+                        await run({ input: finalPayload });
+                    }
+                    catch (err) {
+                        iterErrors.push(err instanceof Error ? err.message : String(err));
+                    }
+                }
+                if (iterErrors.length === 0) {
+                    status = automation_delivery_1.AutomationDeliveryStatus.SUCCESS;
+                }
+                else {
+                    status = automation_delivery_1.AutomationDeliveryStatus.FAILED;
+                    errorMessage = `${iterErrors.length}/${cappedItems.length} iterations failed: ${iterErrors.slice(0, 3).join('; ')}`;
+                }
+            }
+            else {
+                const mappedPayload = applyMappingsWithCoercion(sourceData, mappings);
+                const finalPayload = applyStaticValues(mappedPayload, statics);
+                await run({ input: finalPayload });
+                status = automation_delivery_1.AutomationDeliveryStatus.SUCCESS;
+            }
+        }
+    }
+    catch (err) {
+        status = automation_delivery_1.AutomationDeliveryStatus.FAILED;
+        errorMessage = err instanceof Error ? err.message : String(err);
+    }
+    return { status, responseStatus, responseBody, errorMessage };
+}
+// ─── High-level: dispatch + record delivery ───────────────────────────────────
+/**
+ * Execute an action and record the delivery.
+ * This is the main entry point used by the subscriber and webhook handler.
+ */
+async function dispatchAndRecord(container, action, sourceData, eventName, opts = {}) {
+    const automationService = container.resolve(automation_1.AUTOMATION_MODULE);
+    const result = await dispatchAction(container, action, sourceData, opts);
+    await automationService.createAutomationDeliveries({
+        action_id: action.id,
+        event_name: eventName,
+        request_payload: sourceData,
+        response_status: result.responseStatus,
+        response_body: result.responseBody,
+        status: result.status,
+        attempts: 1,
+        error_message: result.errorMessage
+    });
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatch.js","sourceRoot":"","sources":["../../../../src/lib/dispatch.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/modules/automation/index.d.ts

@@ -0,0 +1,92 @@
+import { AutomationService } from './service';
+export declare const AUTOMATION_MODULE = "automation";
+declare const _default: import("@medusajs/types").ModuleExports<typeof AutomationService> & {
+    linkable: {
+        readonly automationTrigger: {
+            id: {
+                serviceName: "automation";
+                field: "automationTrigger";
+                linkable: "automation_trigger_id";
+                primaryKey: "id";
+            };
+            toJSON: () => {
+                serviceName: "automation";
+                field: "automationTrigger";
+                linkable: "automation_trigger_id";
+                primaryKey: "id";
+            };
+        };
+        readonly automationAction: {
+            id: {
+                serviceName: "automation";
+                field: "automationAction";
+                linkable: "automation_action_id";
+                primaryKey: "id";
+            };
+            toJSON: () => {
+                serviceName: "automation";
+                field: "automationAction";
+                linkable: "automation_action_id";
+                primaryKey: "id";
+            };
+        };
+        readonly automationDelivery: {
+            id: {
+                serviceName: "automation";
+                field: "automationDelivery";
+                linkable: "automation_delivery_id";
+                primaryKey: "id";
+            };
+            toJSON: () => {
+                serviceName: "automation";
+                field: "automationDelivery";
+                linkable: "automation_delivery_id";
+                primaryKey: "id";
+            };
+        };
+        readonly automationReceipt: {
+            id: {
+                serviceName: "automation";
+                field: "automationReceipt";
+                linkable: "automation_receipt_id";
+                primaryKey: "id";
+            };
+            toJSON: () => {
+                serviceName: "automation";
+                field: "automationReceipt";
+                linkable: "automation_receipt_id";
+                primaryKey: "id";
+            };
+        };
+        readonly automationQuery: {
+            id: {
+                serviceName: "automation";
+                field: "automationQuery";
+                linkable: "automation_query_id";
+                primaryKey: "id";
+            };
+            toJSON: () => {
+                serviceName: "automation";
+                field: "automationQuery";
+                linkable: "automation_query_id";
+                primaryKey: "id";
+            };
+        };
+        readonly automationSecret: {
+            id: {
+                serviceName: "automation";
+                field: "automationSecret";
+                linkable: "automation_secret_id";
+                primaryKey: "id";
+            };
+            toJSON: () => {
+                serviceName: "automation";
+                field: "automationSecret";
+                linkable: "automation_secret_id";
+                primaryKey: "id";
+            };
+        };
+    };
+};
+export default _default;
+export * from './service';