deepline 0.3.293 → 0.3.295

package/dist/monitor-input-contract.js

@@ -1,392 +1,12 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./cli/chunk-UNEMDKXN.js');
 
-// src/monitor-input-contract.ts
-var monitor_input_contract_exports = {};
-__export(monitor_input_contract_exports, {
-  lintMonitorBatchInput: () => lintMonitorBatchInput,
-  lintMonitorSpecTemplate: () => lintMonitorSpecTemplate,
-  renderMonitorSpecTemplate: () => renderMonitorSpecTemplate
-});
-module.exports = __toCommonJS(monitor_input_contract_exports);
 
-// ../integration-contracts/monitor-input-contract.ts
-var import_handlebars = __toESM(require("handlebars"), 1);
-function authoredMonitorFieldPath(path, field) {
-  const batch = /^monitors\.(\d+)$/.exec(path);
-  return `${batch ? `monitors[${batch[1]}]` : path}.${field}`;
-}
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function json(value, path, issues) {
-  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
-    return;
-  }
-  if (Array.isArray(value)) {
-    value.forEach((child, index) => json(child, `${path}.${index}`, issues));
-    return;
-  }
-  const object = record(value);
-  if (!object) {
-    issues.push({
-      severity: "error",
-      code: "invalid_monitor_json_value",
-      path,
-      message: "Monitor values must be JSON values."
-    });
-    return;
-  }
-  for (const [key, child] of Object.entries(object)) {
-    json(child, `${path}.${key}`, issues);
-  }
-}
-function monitorSpec(value, path, issues) {
-  const input = record(value);
-  if (!input) {
-    issues.push({
-      severity: "error",
-      code: "invalid_monitor_spec",
-      path,
-      message: "A monitor must be a JSON object."
-    });
-    return null;
-  }
-  const allowed = /* @__PURE__ */ new Set(["key", "tool", "name", "payload"]);
-  for (const key2 of Object.keys(input)) {
-    if (!allowed.has(key2)) {
-      if (key2 === "controls") {
-        issues.push({
-          severity: "error",
-          code: "CONTROLS_NOT_SUPPORTED",
-          path: authoredMonitorFieldPath(path, "controls"),
-          message: "Operational controls are managed by Deepline and cannot be authored in Batch or Fleet JSON.",
-          suggestion: "Remove controls. Bind downstream automation in a Play with sqlListeners."
-        });
-        continue;
-      }
-      if (key2 === "play") {
-        issues.push({
-          severity: "error",
-          code: "PLAY_BINDING_NOT_IN_MONITOR_SPEC",
-          path: authoredMonitorFieldPath(path, "play"),
-          message: "A monitor does not own Play bindings.",
-          suggestion: "Declare sqlListeners in the Play, or run: deepline plays bootstrap monitor-triggered --out on-event.play.ts"
-        });
-        continue;
-      }
-      issues.push({
-        severity: "error",
-        code: "unknown_monitor_field",
-        path: `${path}.${key2}`,
-        message: `Monitor definitions do not accept '${key2}'.`
-      });
-    }
-  }
-  const key = typeof input.key === "string" ? input.key.trim() : "";
-  const tool = typeof input.tool === "string" ? input.tool.trim() : "";
-  const name = input.name === void 0 ? void 0 : typeof input.name === "string" && input.name.trim() ? input.name.trim() : null;
-  const payload = record(input.payload);
-  if (!key) {
-    issues.push({
-      severity: "error",
-      code: "invalid_monitor_key",
-      path: `${path}.key`,
-      message: "Monitor key must be a non-empty string."
-    });
-  }
-  if (!tool) {
-    issues.push({
-      severity: "error",
-      code: "invalid_monitor_tool",
-      path: `${path}.tool`,
-      message: "Monitor tool must be a non-empty literal string."
-    });
-  }
-  if (name === null) {
-    issues.push({
-      severity: "error",
-      code: "invalid_monitor_name",
-      path: `${path}.name`,
-      message: "Monitor name must be a non-empty string when supplied."
-    });
-  }
-  if (!payload) {
-    issues.push({
-      severity: "error",
-      code: "invalid_monitor_payload",
-      path: `${path}.payload`,
-      message: "Monitor payload must be an object."
-    });
-  } else {
-    json(payload, `${path}.payload`, issues);
-  }
-  if (!key || !tool || !payload || name === null) {
-    return null;
-  }
-  return {
-    key,
-    tool,
-    ...name ? { name } : {},
-    payload
-  };
-}
-function issueOrder(left, right) {
-  return left.path.localeCompare(right.path) || left.severity.localeCompare(right.severity) || left.code.localeCompare(right.code);
-}
-function lintMonitorBatchInput(value) {
-  const issues = [];
-  const versionlessEnvelope = !Array.isArray(value) && (() => {
-    const candidate = record(value);
-    return candidate !== null && Object.keys(candidate).length === 1 && Object.prototype.hasOwnProperty.call(candidate, "monitors");
-  })();
-  const legacy = Array.isArray(value) || versionlessEnvelope;
-  const input = legacy ? null : record(value);
-  let monitors = Array.isArray(value) ? value : versionlessEnvelope ? (() => {
-    const candidate = record(value)?.monitors;
-    return Array.isArray(candidate) ? candidate : null;
-  })() : null;
-  if (Array.isArray(value)) {
-    issues.push({
-      severity: "warning",
-      code: "deprecated_batch_array",
-      path: "",
-      message: "Bare monitor arrays are supported for compatibility.",
-      suggestion: 'Wrap the list in {"version":1,"kind":"batch","monitors":[...]}.'
-    });
-  } else if (versionlessEnvelope) {
-    issues.push({
-      severity: "warning",
-      code: "deprecated_batch_missing_envelope_fields",
-      path: "",
-      message: "Versionless monitor envelopes are supported for compatibility.",
-      suggestion: 'Add "version": 1 and "kind": "batch".'
-    });
-    if (!monitors) {
-      issues.push({
-        severity: "error",
-        code: "invalid_batch_monitors",
-        path: "monitors",
-        message: "Batch monitors must be an array."
-      });
-    }
-  } else if (!input) {
-    issues.push({
-      severity: "error",
-      code: "invalid_batch",
-      path: "",
-      message: "Batch input must be an object or a legacy array."
-    });
-  } else {
-    for (const key of Object.keys(input)) {
-      if (!["version", "kind", "monitors"].includes(key)) {
-        issues.push({
-          severity: "error",
-          code: key === "source" || key === "monitor" ? "batch_fleet_shape_mixup" : "unknown_batch_field",
-          path: key,
-          message: `Batch input does not accept '${key}'.`
-        });
-      }
-    }
-    if (input.version !== 1) {
-      issues.push({
-        severity: "error",
-        code: "unsupported_batch_version",
-        path: "version",
-        message: "Batch input version must be 1."
-      });
-    }
-    if (input.kind !== "batch") {
-      issues.push({
-        severity: "error",
-        code: "invalid_batch_kind",
-        path: "kind",
-        message: 'Batch input kind must be "batch".'
-      });
-    }
-    monitors = Array.isArray(input.monitors) ? input.monitors : null;
-    if (!monitors) {
-      issues.push({
-        severity: "error",
-        code: "invalid_batch_monitors",
-        path: "monitors",
-        message: "Batch monitors must be an array."
-      });
-    }
-  }
-  if (!monitors || monitors.length === 0) {
-    if (monitors?.length === 0) {
-      issues.push({
-        severity: "error",
-        code: "empty_batch",
-        path: "monitors",
-        message: "A Batch needs at least one monitor."
-      });
-    }
-    return { issues: issues.sort(issueOrder) };
-  }
-  const normalized = monitors.map(
-    (item, index) => monitorSpec(item, `monitors.${index}`, issues)
-  );
-  const seen = /* @__PURE__ */ new Map();
-  normalized.forEach((item, index) => {
-    if (!item) return;
-    const first = seen.get(item.key);
-    if (first !== void 0) {
-      for (const position of [first, index]) {
-        issues.push({
-          severity: "error",
-          code: "duplicate_monitor_key",
-          path: `monitors.${position}.key`,
-          message: `Duplicate monitor key '${item.key}'.`
-        });
-      }
-    } else {
-      seen.set(item.key, index);
-    }
-  });
-  const ordered = issues.sort(issueOrder);
-  return ordered.some((issue) => issue.severity === "error") ? { issues: ordered } : {
-    normalized: {
-      version: 1,
-      kind: "batch",
-      monitors: normalized
-    },
-    issues: ordered
-  };
-}
-function validateHandlebars(value, path, issues) {
-  if (!value.includes("{{")) return;
-  try {
-    import_handlebars.default.parse(value);
-  } catch (error) {
-    issues.push({
-      severity: "error",
-      code: "invalid_handlebars_template",
-      path,
-      message: error instanceof Error ? error.message : "Invalid Handlebars template."
-    });
-    return;
-  }
-  const expressions = value.match(/{{[\s\S]*?}}/g) ?? [];
-  if (expressions.some(
-    (expression) => !/^{{\s*[A-Za-z_][A-Za-z0-9_]*\s*}}$/.test(expression)
-  )) {
-    issues.push({
-      severity: "error",
-      code: "unsupported_handlebars_expression",
-      path,
-      message: "Fleet templates allow only direct source-row fields such as {{domain}}; helpers, blocks, partials, paths, and prototype access are disabled."
-    });
-  }
-}
-function walkTemplates(value, path, issues) {
-  if (typeof value === "string") return validateHandlebars(value, path, issues);
-  if (Array.isArray(value)) {
-    value.forEach(
-      (item, index) => walkTemplates(item, `${path}.${index}`, issues)
-    );
-    return;
-  }
-  const input = record(value);
-  if (!input) return;
-  for (const [key, child] of Object.entries(input)) {
-    walkTemplates(child, `${path}.${key}`, issues);
-  }
-}
-function lintMonitorSpecTemplate(value, path = "monitor") {
-  const issues = [];
-  const normalized = monitorSpec(value, path, issues);
-  const input = record(value);
-  if (input && typeof input.tool === "string" && input.tool.includes("{{")) {
-    issues.push({
-      severity: "error",
-      code: "templated_monitor_tool",
-      path: `${path}.tool`,
-      message: "Fleet monitor tool must be literal; only key, name, and payload may be templated."
-    });
-  }
-  if (input) {
-    for (const field of ["key", "name", "payload"]) {
-      if (input[field] !== void 0)
-        walkTemplates(input[field], `${path}.${field}`, issues);
-    }
-  }
-  const ordered = issues.sort(issueOrder);
-  return ordered.some((issue) => issue.severity === "error") ? { issues: ordered } : { normalized, issues: ordered };
-}
-function renderValue(value, row) {
-  if (typeof value === "string" && value.includes("{{")) {
-    const context = Object.assign(/* @__PURE__ */ Object.create(null), row);
-    return import_handlebars.default.compile(value, {
-      noEscape: true,
-      strict: true,
-      knownHelpersOnly: true,
-      preventIndent: true
-    })(context, {
-      allowProtoMethodsByDefault: false,
-      allowProtoPropertiesByDefault: false,
-      helpers: /* @__PURE__ */ Object.create(null),
-      partials: /* @__PURE__ */ Object.create(null)
-    });
-  }
-  if (Array.isArray(value)) return value.map((item) => renderValue(item, row));
-  const input = record(value);
-  if (!input) return value;
-  return Object.fromEntries(
-    Object.entries(input).map(([key, item]) => [key, renderValue(item, row)])
-  );
-}
-function renderMonitorSpecTemplate(template, row) {
-  const lint = lintMonitorSpecTemplate(template);
-  if (!lint.normalized) return { issues: lint.issues };
-  try {
-    const rendered = renderValue(lint.normalized, row);
-    const issues = [];
-    const spec = monitorSpec(rendered, "monitor", issues);
-    return spec ? { spec, issues: issues.sort(issueOrder) } : { issues: issues.sort(issueOrder) };
-  } catch (error) {
-    return {
-      issues: [
-        {
-          severity: "error",
-          code: "monitor_template_render_failed",
-          path: "monitor",
-          message: error instanceof Error ? error.message : "Fleet template rendering failed."
-        }
-      ]
-    };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  lintMonitorBatchInput,
-  lintMonitorSpecTemplate,
-  renderMonitorSpecTemplate
-});
+
+
+var _chunkWOHBA5PVjs = require('./cli/chunk-WOHBA5PV.js');
+require('./cli/chunk-COGTRVWW.js');
+
+
+
+
+exports.lintMonitorBatchInput = _chunkWOHBA5PVjs.lintMonitorBatchInput; exports.lintMonitorSpecTemplate = _chunkWOHBA5PVjs.lintMonitorSpecTemplate; exports.renderMonitorSpecTemplate = _chunkWOHBA5PVjs.renderMonitorSpecTemplate;