@objectstack/service-automation 4.0.4 → 4.0.5

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/engine.ts
 import { FlowSchema } from "@objectstack/spec/automation";
 var AutomationEngine = class {
@@ -426,7 +433,38 @@ var AutomationEngine = class {
    * boolean literals (true, false), and basic arithmetic.
    */
   evaluateCondition(expression, variables) {
-    let resolved = expression;
+    const isEnvelope = typeof expression === "object" && expression != null && "dialect" in expression;
+    const dialect = isEnvelope ? expression.dialect : void 0;
+    const exprStr = typeof expression === "string" ? expression : expression?.source ?? "";
+    if (isEnvelope && dialect && dialect !== "cel" && dialect !== "flow" && dialect !== "template") {
+      return false;
+    }
+    if (dialect === "cel" || isEnvelope && !dialect) {
+      try {
+        const { ExpressionEngine } = __require("@objectstack/formula");
+        const vars = {};
+        for (const [key, value] of variables) {
+          const segs = key.split(".");
+          let cursor = vars;
+          for (let i = 0; i < segs.length - 1; i++) {
+            if (typeof cursor[segs[i]] !== "object" || cursor[segs[i]] === null) {
+              cursor[segs[i]] = {};
+            }
+            cursor = cursor[segs[i]];
+          }
+          cursor[segs[segs.length - 1]] = value;
+        }
+        const result = ExpressionEngine.evaluate(
+          { dialect: "cel", source: exprStr },
+          { extra: { vars }, record: vars }
+        );
+        if (!result.ok) return false;
+        return Boolean(result.value);
+      } catch {
+        return false;
+      }
+    }
+    let resolved = exprStr;
     for (const [key, value] of variables) {
       resolved = resolved.split(`{${key}}`).join(String(value));
     }
@@ -607,6 +645,9 @@ var AutomationServicePlugin = class {
     this.name = "com.objectstack.service-automation";
     this.version = "1.0.0";
     this.type = "standard";
+    // Soft dependency on metadata: we look it up at start() and tolerate absence.
+    // Do NOT declare a hard kernel dependency, so this plugin works in environments
+    // where MetadataPlugin is not registered.
     this.dependencies = [];
     this.options = options;
   }
@@ -621,18 +662,149 @@ var AutomationServicePlugin = class {
     ctx.logger.info("[Automation] Engine initialized");
   }
   async start(ctx) {
-    if (!this.engine) return;
+    console.warn("[Automation:start] entering start()");
+    if (!this.engine) {
+      console.warn("[Automation:start] engine missing, bailing");
+      return;
+    }
     await ctx.trigger("automation:ready", this.engine);
     const nodeTypes = this.engine.getRegisteredNodeTypes();
     ctx.logger.info(
       `[Automation] Engine started with ${nodeTypes.length} node types: ${nodeTypes.join(", ") || "(none)"}`
     );
+    try {
+      const ql = ctx.getService("objectql");
+      if (!ql) {
+        console.warn("[Automation] objectql service not found at start()");
+      } else if (!ql.registry) {
+        console.warn("[Automation] objectql.registry is undefined at start()");
+      } else if (typeof ql.registry.listItems !== "function") {
+        console.warn("[Automation] objectql.registry.listItems is not a function");
+      }
+      const flows = ql?.registry?.listItems?.("flow") ?? [];
+      console.warn(`[Automation] flow pull: registry returned ${flows.length} flow(s)`);
+      let registered = 0;
+      for (const f of flows) {
+        const def = f;
+        if (!def?.name) continue;
+        try {
+          this.engine.registerFlow(def.name, def);
+          registered++;
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          ctx.logger.warn(`[Automation] failed to register flow ${def.name}: ${msg}`);
+        }
+      }
+      if (registered > 0) {
+        ctx.logger.info(`[Automation] Pulled ${registered} flow(s) from ObjectQL registry`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.logger.warn(`[Automation] flow pull from ObjectQL registry failed: ${msg}`);
+    }
   }
   async destroy() {
     this.engine = void 0;
   }
 };
 
+// src/plugins/template.ts
+function resolvePath(base, path) {
+  let cur = base;
+  for (const seg of path) {
+    if (cur == null) return void 0;
+    if (typeof cur !== "object") return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function resolveToken(token, variables, context) {
+  const trimmed = token.trim();
+  if (!trimmed) return void 0;
+  const dateFnMatch = /^(NOW|TODAY)\s*\(\s*\)\s*(?:([+\-])\s*(\S+))?$/.exec(trimmed);
+  if (dateFnMatch) {
+    const fn = dateFnMatch[1];
+    const sign = dateFnMatch[2] === "-" ? -1 : 1;
+    const offsetRaw = dateFnMatch[3];
+    let offset = 0;
+    if (offsetRaw) {
+      const asNum = Number(offsetRaw);
+      if (!isNaN(asNum)) {
+        offset = asNum;
+      } else if (variables.has(offsetRaw)) {
+        offset = Number(variables.get(offsetRaw)) || 0;
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (offset) now.setDate(now.getDate() + sign * offset);
+    if (fn === "NOW") return now.toISOString();
+    return now.toISOString().slice(0, 10);
+  }
+  if (trimmed.startsWith("$User.")) {
+    const path = trimmed.slice("$User.".length).split(".");
+    if (path[0] === "Id") return context.userId;
+    if (path[0] === "Email") return resolvePath(context.user, ["email", ...path.slice(1)]) ?? void 0;
+    return resolvePath(context.user, path);
+  }
+  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(trimmed)) {
+    const segments = trimmed.split(".");
+    const head = segments[0];
+    if (variables.has(head)) {
+      return resolvePath(variables.get(head), segments.slice(1));
+    }
+    if (variables.has(trimmed)) return variables.get(trimmed);
+    return void 0;
+  }
+  if (!/^[\w\s+\-*/%().,?:<>=!&|"'$]+$/.test(trimmed)) return void 0;
+  let safe = trimmed;
+  safe = safe.replace(/([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g, (match) => {
+    if (match === "true" || match === "false" || match === "null" || match === "undefined") return match;
+    const segs = match.split(".");
+    const head = segs[0];
+    let val;
+    if (variables.has(head)) val = resolvePath(variables.get(head), segs.slice(1));
+    else if (variables.has(match)) val = variables.get(match);
+    if (val === void 0 || val === null) return "null";
+    if (typeof val === "number" || typeof val === "boolean") return String(val);
+    return JSON.stringify(String(val));
+  });
+  try {
+    const fn = new Function(`"use strict"; return (${safe});`);
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+function interpolateString(input, variables, context) {
+  if (!input.includes("{")) return input;
+  const single = /^\{([^{}]+)\}$/.exec(input);
+  if (single) {
+    const value = resolveToken(single[1], variables, context);
+    return value;
+  }
+  return input.replace(/\{([^{}]+)\}/g, (_match, expr) => {
+    const value = resolveToken(expr, variables, context);
+    if (value === void 0 || value === null) return "";
+    return String(value);
+  });
+}
+function interpolate(value, variables, context) {
+  if (typeof value === "string") {
+    return interpolateString(value, variables, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => interpolate(v, variables, context));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = interpolate(v, variables, context);
+    }
+    return out;
+  }
+  return value;
+}
+
 // src/plugins/crud-nodes-plugin.ts
 var CrudNodesPlugin = class {
   constructor() {
@@ -643,39 +815,105 @@ var CrudNodesPlugin = class {
   }
   async init(ctx) {
     const engine = ctx.getService("automation");
+    const getData = () => {
+      try {
+        return ctx.getService("data") ?? ctx.getService("objectql");
+      } catch {
+        return void 0;
+      }
+    };
     engine.registerNodeExecutor({
       type: "get_record",
-      async execute(node, _variables, _context) {
-        const config = node.config;
-        return {
-          success: true,
-          output: { records: [], object: config?.object }
-        };
+      async execute(node, variables, context) {
+        const cfg = node.config ?? {};
+        const objectName = String(cfg.objectName ?? cfg.object ?? "");
+        if (!objectName) return { success: false, error: "get_record: objectName required" };
+        const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
+        const fields = cfg.fields;
+        const limit = typeof cfg.limit === "number" ? cfg.limit : void 0;
+        const outputVariable = cfg.outputVariable;
+        const data = getData();
+        if (!data) {
+          ctx.logger.warn(`[get_record] no data engine; skipping ${objectName}`);
+          return { success: true, output: { records: [], object: objectName } };
+        }
+        try {
+          if (limit && limit > 1) {
+            const records = await data.find(objectName, { where: filter, fields, limit });
+            if (outputVariable) variables.set(outputVariable, records);
+            return { success: true, output: { records, object: objectName } };
+          }
+          const record = await data.findOne(objectName, { where: filter, fields });
+          if (outputVariable) variables.set(outputVariable, record);
+          return { success: true, output: { record, id: record?.id, object: objectName } };
+        } catch (err) {
+          return { success: false, error: `get_record(${objectName}) failed: ${err.message}` };
+        }
       }
     });
     engine.registerNodeExecutor({
       type: "create_record",
-      async execute(node, _variables, _context) {
-        const config = node.config;
-        return {
-          success: true,
-          output: { id: "new-record-id", object: config?.object }
-        };
+      async execute(node, variables, context) {
+        const cfg = node.config ?? {};
+        const objectName = String(cfg.objectName ?? cfg.object ?? "");
+        if (!objectName) return { success: false, error: "create_record: objectName required" };
+        const fields = interpolate(cfg.fields ?? {}, variables, context);
+        const outputVariable = cfg.outputVariable;
+        const data = getData();
+        if (!data) {
+          ctx.logger.warn(`[create_record] no data engine; skipping ${objectName}`);
+          if (outputVariable) variables.set(outputVariable, `mock-${objectName}-${Date.now()}`);
+          return { success: true, output: { id: `mock-${objectName}-${Date.now()}`, object: objectName } };
+        }
+        try {
+          const created = await data.insert(objectName, fields);
+          const insertedId = Array.isArray(created) ? created[0]?.id : created?.id ?? created;
+          if (outputVariable) variables.set(outputVariable, insertedId);
+          return { success: true, output: { id: insertedId, record: created, object: objectName } };
+        } catch (err) {
+          return { success: false, error: `create_record(${objectName}) failed: ${err.message}` };
+        }
       }
     });
     engine.registerNodeExecutor({
       type: "update_record",
-      async execute(_node, _variables, _context) {
-        return { success: true };
+      async execute(node, variables, context) {
+        const cfg = node.config ?? {};
+        const objectName = String(cfg.objectName ?? cfg.object ?? "");
+        if (!objectName) return { success: false, error: "update_record: objectName required" };
+        const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
+        const fields = interpolate(cfg.fields ?? {}, variables, context);
+        const data = getData();
+        if (!data) {
+          ctx.logger.warn(`[update_record] no data engine; skipping ${objectName}`);
+          return { success: true };
+        }
+        try {
+          const result = await data.update(objectName, fields, { where: filter });
+          return { success: true, output: { result, object: objectName } };
+        } catch (err) {
+          return { success: false, error: `update_record(${objectName}) failed: ${err.message}` };
+        }
       }
     });
     engine.registerNodeExecutor({
       type: "delete_record",
-      async execute(_node, _variables, _context) {
-        return { success: true };
+      async execute(node, variables, context) {
+        const cfg = node.config ?? {};
+        const objectName = String(cfg.objectName ?? cfg.object ?? "");
+        if (!objectName) return { success: false, error: "delete_record: objectName required" };
+        const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
+        const data = getData();
+        if (!data) return { success: true };
+        try {
+          const result = await data.delete(objectName, { where: filter });
+          return { success: true, output: { result, object: objectName } };
+        } catch (err) {
+          return { success: false, error: `delete_record(${objectName}) failed: ${err.message}` };
+        }
       }
     });
-    ctx.logger.info("[CRUD Nodes] 4 node executors registered");
+    ctx.logger.info("[CRUD Nodes] 4 node executors registered (data-backed)");
   }
 };
 
@@ -781,11 +1019,54 @@ var HttpConnectorPlugin = class {
     ctx.logger.info("[HTTP Connector] 2 node executors registered");
   }
 };
+
+// src/plugins/screen-nodes-plugin.ts
+var ScreenNodesPlugin = class {
+  constructor() {
+    this.name = "com.objectstack.automation.screen-nodes";
+    this.version = "1.0.0";
+    this.type = "standard";
+    this.dependencies = ["com.objectstack.service-automation"];
+  }
+  async init(ctx) {
+    const engine = ctx.getService("automation");
+    engine.registerNodeExecutor({
+      type: "screen",
+      async execute(_node, _variables, _context) {
+        return { success: true };
+      }
+    });
+    engine.registerNodeExecutor({
+      type: "script",
+      async execute(node, _variables, _context) {
+        const cfg = node.config ?? {};
+        const actionType = cfg.actionType ?? "noop";
+        if (actionType === "email") {
+          ctx.logger.info(
+            `[Script:email] template=${String(cfg.template)} recipients=${JSON.stringify(cfg.recipients)} vars=${JSON.stringify(cfg.variables)}`
+          );
+          return {
+            success: true,
+            output: {
+              actionType,
+              template: cfg.template,
+              recipients: cfg.recipients
+            }
+          };
+        }
+        ctx.logger.info(`[Script:${actionType}] node=${node.id} executed (no-op handler)`);
+        return { success: true, output: { actionType } };
+      }
+    });
+    ctx.logger.info("[Screen/Script Nodes] 2 node executors registered");
+  }
+};
 export {
   AutomationEngine,
   AutomationServicePlugin,
   CrudNodesPlugin,
   HttpConnectorPlugin,
-  LogicNodesPlugin
+  LogicNodesPlugin,
+  ScreenNodesPlugin
 };
 //# sourceMappingURL=index.js.map