callman-mcp 0.1.0 → 0.2.0

package/dist-cjs/domain/requestIntegrations.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrationsInputView = exports.toIntegrationPayload = exports.connectionResolver = exports.hasIntegrations = exports.requestIntegrationFields = void 0;
+const zod_1 = require("zod");
+const errors_js_1 = require("../client/errors.js");
+const strict_js_1 = require("../lib/strict.js");
+// A saved request's integration steps — the desktop's Database / Kafka /
+// Redis tabs, DB assertions and the Kafka script. Field names mirror the
+// backend's request schema so what get_request returns can be sent back;
+// ids of list items are generated when omitted, and `connectionId` accepts a
+// connection id OR name (list_connections).
+const connectionRef = zod_1.z.string().trim().min(1).max(200).describe("Connection id or name from list_connections");
+const dbStepSchema = (0, strict_js_1.strictObject)({
+    enabled: zod_1.z.boolean().optional().describe("Default true"),
+    connectionId: connectionRef,
+    query: zod_1.z.string().max(100_000).describe("SQL (or a MongoDB command) run on the connection; {{variables}} are resolved"),
+}, "database step field");
+const databaseSchema = (0, strict_js_1.strictObject)({
+    preRequest: dbStepSchema.nullable().optional().describe("Runs before the request; null turns it off"),
+    postResponse: dbStepSchema.nullable().optional().describe("Runs after the response; null turns it off"),
+}, "database field").describe("Database steps. On update, a phase you leave out is kept as it is.");
+const COMPARE = ["equals", "not_equals", "exists", "gt", "lt"];
+const kafkaPublishSchema = (0, strict_js_1.strictObject)({
+    enabled: zod_1.z.boolean().optional().describe("Default true"),
+    connectionId: connectionRef,
+    topic: zod_1.z.string().min(1).max(1000),
+    valueFormat: zod_1.z.enum(["json", "raw"]).optional().describe("Default json"),
+    key: zod_1.z.string().max(4000).optional(),
+    value: zod_1.z.string().max(200_000).describe("Message value; {{variables}} are resolved"),
+    headers: zod_1.z.array((0, strict_js_1.strictObject)({ id: zod_1.z.string().max(200).optional(), key: zod_1.z.string().max(1000), value: zod_1.z.string().max(10_000).default(""), enabled: zod_1.z.boolean().optional() }, "kafka header field")).max(200).optional(),
+    continueOnFailure: zod_1.z.boolean().optional().describe("Default true"),
+}, "kafka publish field");
+const kafkaSchema = (0, strict_js_1.strictObject)({
+    enabled: zod_1.z.boolean().optional().describe("Consume: wait for a message on `topic` after the response (default true when a topic is given)"),
+    connectionId: connectionRef.optional(),
+    topic: zod_1.z.string().max(1000).optional(),
+    timeoutMs: zod_1.z.number().int().min(100).max(300_000).optional().describe("How long to wait for the message (default 5000)"),
+    matchMode: zod_1.z.enum(["regex", "rules"]).optional().describe("Pick the message by a regex on its value, or by `assertions`"),
+    matchPattern: zod_1.z.string().max(2000).optional(),
+    assertions: zod_1.z
+        .array((0, strict_js_1.strictObject)({
+        id: zod_1.z.string().max(200).optional(),
+        name: zod_1.z.string().min(1).max(500),
+        field: zod_1.z.string().min(1).max(2000).describe("Path in the consumed message, e.g. value.orderId"),
+        operator: zod_1.z.enum(COMPARE),
+        valueType: zod_1.z.enum(["static", "template"]).optional().describe("template resolves {{variables}} in value"),
+        value: zod_1.z.string().max(10_000).optional(),
+    }, "kafka assertion field"))
+        .max(500)
+        .optional(),
+    prePublish: kafkaPublishSchema.nullable().optional().describe("Publish a message before the request; null turns it off"),
+    postPublish: kafkaPublishSchema.nullable().optional().describe("Publish a message after the response; null turns it off"),
+}, "kafka field").describe("Kafka steps. On update, fields you leave out are kept.");
+const redisSchema = (0, strict_js_1.strictObject)({
+    enabled: zod_1.z.boolean().optional().describe("Default true"),
+    connectionId: connectionRef,
+    preCommands: zod_1.z.array(zod_1.z.string().min(1).max(4000)).max(500).optional().describe('Commands before the request, e.g. "SET user:1 active"'),
+    postCommands: zod_1.z.array(zod_1.z.string().min(1).max(4000)).max(500).optional(),
+    assertions: zod_1.z
+        .array((0, strict_js_1.strictObject)({
+        id: zod_1.z.string().max(200).optional(),
+        name: zod_1.z.string().min(1).max(500),
+        key: zod_1.z.string().min(1).max(2000),
+        operator: zod_1.z.enum(["equals", "contains", "exists", "not_exists", "gt"]),
+        value: zod_1.z.string().max(10_000).optional(),
+    }, "redis assertion field"))
+        .max(500)
+        .optional(),
+}, "redis field");
+const dbAssertionSchema = (0, strict_js_1.strictObject)({
+    id: zod_1.z.string().max(200).optional(),
+    name: zod_1.z.string().min(1).max(500),
+    source: zod_1.z.enum(["db_pre", "db_post"]).describe("Which database step's result to check"),
+    field: zod_1.z.string().min(1).max(2000).describe("Dot path into the step's { success, rowCount, rows, firstRow, error }, e.g. firstRow.status, rowCount, rows.1.id"),
+    operator: zod_1.z.enum(COMPARE),
+    valueType: zod_1.z.enum(["static", "response"]).optional().describe('static (default): value as written; response: value is a template such as "{{response.id}}" (response body path) or "{{db_pre.firstRow.id}}"'),
+    value: zod_1.z.string().max(10_000).optional(),
+}, "db assertion field");
+exports.requestIntegrationFields = {
+    database: databaseSchema.optional(),
+    kafka: kafkaSchema.nullable().optional().describe("Kafka steps; null turns all of them off"),
+    redis: redisSchema.nullable().optional().describe("Redis steps; null turns them off"),
+    dbAssertions: zod_1.z.array(dbAssertionSchema).max(500).optional().describe("Checks on the database steps' results (replaces the list)"),
+    kafkaScript: zod_1.z.string().max(100_000).optional().describe("Script run with the consumed Kafka message"),
+};
+const hasIntegrations = (input) => input.database !== undefined || input.kafka !== undefined || input.redis !== undefined || input.dbAssertions !== undefined || input.kafkaScript !== undefined;
+exports.hasIntegrations = hasIntegrations;
+let counter = 0;
+const newId = (prefix) => `${prefix}_${Date.now().toString(36)}${(counter++).toString(36)}`;
+// connectionId (id or name) → id, checked against the workspace's
+// connections of the right type.
+const connectionResolver = (connections) => (ref, type, where) => {
+    const byId = connections.find((connection) => connection.id === ref);
+    const byName = connections.filter((connection) => connection.name.toLowerCase() === ref.toLowerCase());
+    const found = byId ?? (byName.length === 1 ? byName[0] : undefined);
+    if (!found) {
+        const candidates = connections.filter((connection) => connection.type === type).map((connection) => ({ id: connection.id, name: connection.name, provider: connection.provider }));
+        throw new errors_js_1.ToolInputError(byName.length > 1 ? "REF_AMBIGUOUS" : "CONNECTION_NOT_FOUND", `${where}: no single ${type} connection "${ref}" in this workspace (list_connections shows them).`, { candidates });
+    }
+    if (found.type !== type) {
+        throw new errors_js_1.ToolInputError("CONNECTION_WRONG_TYPE", `${where}: "${found.name}" is a ${found.type} connection, not ${type}.`);
+    }
+    return found.id;
+};
+exports.connectionResolver = connectionResolver;
+const DISABLED_DB_STEP = { enabled: false, connectionId: null, query: "" };
+const DISABLED_PUBLISH = { enabled: false, connectionId: null, topic: "", valueFormat: "json", key: "", value: "", headers: [], continueOnFailure: true };
+const asRecord = (value) => (value && typeof value === "object" ? value : {});
+const publishPayload = (input, resolve, where) => ({
+    enabled: input.enabled ?? true,
+    connectionId: resolve(input.connectionId, "kafka", where),
+    topic: input.topic,
+    valueFormat: input.valueFormat ?? "json",
+    key: input.key ?? "",
+    value: input.value,
+    headers: (input.headers ?? []).map((header) => ({ id: header.id ?? newId("kh"), key: header.key, value: header.value ?? "", enabled: header.enabled ?? true })),
+    continueOnFailure: input.continueOnFailure ?? true,
+});
+// Input → the backend's fields. `current` is the stored request on update:
+// a database phase or kafka field the model left out is kept.
+const toIntegrationPayload = (input, resolve, current) => {
+    const out = {};
+    if (input.database !== undefined) {
+        const stored = asRecord(current?.database);
+        const phase = (value, key) => {
+            if (value === undefined)
+                return stored[key] ?? DISABLED_DB_STEP;
+            if (value === null)
+                return DISABLED_DB_STEP;
+            return { enabled: value.enabled ?? true, connectionId: resolve(value.connectionId, "database", `database.${key}`), query: value.query };
+        };
+        out.database = { preRequest: phase(input.database.preRequest, "preRequest"), postResponse: phase(input.database.postResponse, "postResponse") };
+    }
+    if (input.kafka !== undefined) {
+        if (input.kafka === null) {
+            out.kafka = { enabled: false, connectionId: null, topic: "", timeoutMs: 5000, matchMode: "regex", matchPattern: "", assertions: [], prePublish: DISABLED_PUBLISH, postPublish: DISABLED_PUBLISH };
+        }
+        else {
+            const stored = asRecord(current?.kafka);
+            const kafka = input.kafka;
+            const consumeGiven = kafka.topic !== undefined || kafka.connectionId !== undefined;
+            out.kafka = {
+                ...stored,
+                enabled: kafka.enabled ?? (consumeGiven ? true : (stored.enabled ?? false)),
+                connectionId: kafka.connectionId !== undefined ? resolve(kafka.connectionId, "kafka", "kafka") : (stored.connectionId ?? null),
+                topic: kafka.topic ?? stored.topic ?? "",
+                timeoutMs: kafka.timeoutMs ?? stored.timeoutMs ?? 5000,
+                matchMode: kafka.matchMode ?? stored.matchMode ?? "regex",
+                matchPattern: kafka.matchPattern ?? stored.matchPattern ?? "",
+                assertions: kafka.assertions !== undefined
+                    ? kafka.assertions.map((assertion) => ({ id: assertion.id ?? newId("ka"), name: assertion.name, field: assertion.field, operator: assertion.operator, valueType: assertion.valueType ?? "static", value: assertion.value ?? "" }))
+                    : (stored.assertions ?? []),
+                prePublish: kafka.prePublish === undefined ? (stored.prePublish ?? DISABLED_PUBLISH) : kafka.prePublish === null ? DISABLED_PUBLISH : publishPayload(kafka.prePublish, resolve, "kafka.prePublish"),
+                postPublish: kafka.postPublish === undefined ? (stored.postPublish ?? DISABLED_PUBLISH) : kafka.postPublish === null ? DISABLED_PUBLISH : publishPayload(kafka.postPublish, resolve, "kafka.postPublish"),
+            };
+        }
+    }
+    if (input.redis !== undefined) {
+        out.redis =
+            input.redis === null
+                ? { enabled: false, connectionId: null, preCommands: [], postCommands: [], assertions: [] }
+                : {
+                    enabled: input.redis.enabled ?? true,
+                    connectionId: resolve(input.redis.connectionId, "redis", "redis"),
+                    preCommands: (input.redis.preCommands ?? []).map((command) => ({ id: newId("rc"), command })),
+                    postCommands: (input.redis.postCommands ?? []).map((command) => ({ id: newId("rc"), command })),
+                    assertions: (input.redis.assertions ?? []).map((assertion) => ({ id: assertion.id ?? newId("ra"), name: assertion.name, key: assertion.key, operator: assertion.operator, value: assertion.value ?? "" })),
+                };
+    }
+    if (input.dbAssertions !== undefined) {
+        out.dbAssertions = input.dbAssertions.map((assertion) => ({
+            id: assertion.id ?? newId("da"),
+            name: assertion.name,
+            source: assertion.source,
+            field: assertion.field,
+            operator: assertion.operator,
+            valueType: assertion.valueType ?? "static",
+            value: assertion.value ?? "",
+        }));
+    }
+    if (input.kafkaScript !== undefined)
+        out.kafkaScript = input.kafkaScript;
+    return out;
+};
+exports.toIntegrationPayload = toIntegrationPayload;
+// Stored integration fields → the input shape (only what is switched on).
+const integrationsInputView = (request) => {
+    const out = {};
+    const database = asRecord(request.database);
+    const phase = (value) => {
+        const step = asRecord(value);
+        return step.enabled ? { enabled: true, connectionId: step.connectionId ?? null, query: step.query ?? "" } : undefined;
+    };
+    const pre = phase(database.preRequest);
+    const post = phase(database.postResponse);
+    if (pre || post)
+        out.database = { ...(pre ? { preRequest: pre } : {}), ...(post ? { postResponse: post } : {}) };
+    const kafka = asRecord(request.kafka);
+    const publish = (value) => {
+        const step = asRecord(value);
+        if (!step.enabled)
+            return undefined;
+        const { headers, ...rest } = step;
+        return { ...rest, headers: Array.isArray(headers) ? headers : [] };
+    };
+    const prePublish = publish(kafka.prePublish);
+    const postPublish = publish(kafka.postPublish);
+    if (kafka.enabled || prePublish || postPublish) {
+        out.kafka = {
+            ...(kafka.enabled
+                ? { enabled: true, connectionId: kafka.connectionId ?? null, topic: kafka.topic ?? "", timeoutMs: kafka.timeoutMs ?? 5000, matchMode: kafka.matchMode ?? "regex", matchPattern: kafka.matchPattern ?? "", assertions: kafka.assertions ?? [] }
+                : { enabled: false }),
+            ...(prePublish ? { prePublish } : {}),
+            ...(postPublish ? { postPublish } : {}),
+        };
+    }
+    const redis = asRecord(request.redis);
+    if (redis.enabled) {
+        const commands = (value) => (Array.isArray(value) ? value.map((entry) => String(asRecord(entry).command ?? "")) : []);
+        out.redis = { enabled: true, connectionId: redis.connectionId ?? null, preCommands: commands(redis.preCommands), postCommands: commands(redis.postCommands), assertions: redis.assertions ?? [] };
+    }
+    if (request.dbAssertions && request.dbAssertions.length > 0)
+        out.dbAssertions = request.dbAssertions;
+    if (request.kafkaScript)
+        out.kafkaScript = request.kafkaScript;
+    return Object.keys(out).length > 0 ? out : undefined;
+};
+exports.integrationsInputView = integrationsInputView;