@juhuu/sdk-ts 1.2.263 → 1.2.265

package/dist/index.d.mts

@@ -1697,6 +1697,14 @@ declare class FlowsService extends Service {
     update(FlowUpdateParams: JUHUU.Flow.Update.Params, FlowUpdateOptions?: JUHUU.Flow.Update.Options): Promise<JUHUU.HttpResponse<JUHUU.Flow.Update.Response>>;
     delete(FlowDeleteParams: JUHUU.Flow.Delete.Params, FlowDeleteOptions?: JUHUU.Flow.Delete.Options): Promise<JUHUU.HttpResponse<JUHUU.Flow.Delete.Response>>;
     execute(FlowExecuteParams: JUHUU.Flow.Execute.Params, FlowExecuteOptions?: JUHUU.Flow.Execute.Options): Promise<JUHUU.HttpResponse<JUHUU.Flow.Execute.Response>>;
+    private areInputsAvailable;
+    private resolveInputs;
+    private isInputConnected;
+    private blockExecutors;
+    executeLocally(flowId: string, context?: Record<string, any>): Promise<{
+        output: Record<string, any>;
+        logArray: FlowLog[];
+    }>;
 }
 
 declare class FlowTracesService extends Service {

package/dist/index.d.ts

@@ -1697,6 +1697,14 @@ declare class FlowsService extends Service {
     update(FlowUpdateParams: JUHUU.Flow.Update.Params, FlowUpdateOptions?: JUHUU.Flow.Update.Options): Promise<JUHUU.HttpResponse<JUHUU.Flow.Update.Response>>;
     delete(FlowDeleteParams: JUHUU.Flow.Delete.Params, FlowDeleteOptions?: JUHUU.Flow.Delete.Options): Promise<JUHUU.HttpResponse<JUHUU.Flow.Delete.Response>>;
     execute(FlowExecuteParams: JUHUU.Flow.Execute.Params, FlowExecuteOptions?: JUHUU.Flow.Execute.Options): Promise<JUHUU.HttpResponse<JUHUU.Flow.Execute.Response>>;
+    private areInputsAvailable;
+    private resolveInputs;
+    private isInputConnected;
+    private blockExecutors;
+    executeLocally(flowId: string, context?: Record<string, any>): Promise<{
+        output: Record<string, any>;
+        logArray: FlowLog[];
+    }>;
 }
 
 declare class FlowTracesService extends Service {

package/dist/index.js

@@ -3562,6 +3562,7 @@ var EmzService = class extends Service {
 };
 
 // src/flows/flows.service.ts
+var import_json_logic_js = __toESM(require("json-logic-js"));
 var FlowsService = class extends Service {
   constructor(config) {
     super(config);
@@ -3655,6 +3656,310 @@ var FlowsService = class extends Service {
       FlowExecuteOptions
     );
   }
+  areInputsAvailable(block, outputStore, edgeArray) {
+    if (block.in === null || block.in === void 0) {
+      return true;
+    }
+    return Object.values(block.in).every((edgeId) => {
+      const edge = edgeArray.find((e) => e.id === edgeId);
+      if (edge === void 0) {
+        return false;
+      }
+      if (edge.type === "control") {
+        return true;
+      }
+      const srcOutputs = outputStore[edge.from.blockId];
+      return srcOutputs !== null && srcOutputs !== void 0 && edge.from.output in srcOutputs;
+    });
+  }
+  resolveInputs(block, outputStore, edgeArray) {
+    const inputs = {};
+    if (block.in === void 0) {
+      return inputs;
+    }
+    for (const [inputName, edgeId] of Object.entries(block.in)) {
+      const edge = edgeArray.find((e) => e.id === edgeId);
+      if (edge === void 0) {
+        throw new Error(
+          `No edge found with id ${edgeId} for input ${inputName}`
+        );
+      }
+      if (edge.type === "control") {
+        continue;
+      }
+      const srcOutputs = outputStore[edge.from.blockId];
+      if (srcOutputs === void 0 || edge.from.output in srcOutputs === false) {
+        throw new Error(
+          `Missing output '${edge.from.output}' from block '${edge.from.blockId}'`
+        );
+      }
+      inputs[inputName] = srcOutputs[edge.from.output];
+    }
+    return inputs;
+  }
+  isInputConnected(block, inputName) {
+    if (block.in === void 0 || block.in === null) {
+      return false;
+    }
+    return block.in[inputName] !== void 0;
+  }
+  blockExecutors = {
+    "start.custom": async (_inputs, block, context) => {
+      if (block.type !== "start.custom") {
+        throw new Error(
+          `Invalid block type '${block.type}' for start.custom executor`
+        );
+      }
+      const defs = block.data.inputParamDefinitionArray ?? [];
+      if (defs.length === 0) {
+        return { output: {} };
+      }
+      const outputs = {};
+      for (const param of defs) {
+        const value = context[param.name];
+        if (value === void 0 && param.required) {
+          throw new Error(
+            `Missing required input parameter '${param.name}'`
+          );
+        }
+        outputs[param.name] = value;
+      }
+      return {
+        output: outputs
+      };
+    },
+    "control.if": async (inputs, block) => {
+      const fb = block;
+      const result = import_json_logic_js.default.apply(fb.data.condition, inputs);
+      return {
+        output: {},
+        flowBranch: result === true ? "true" : "false"
+      };
+    },
+    "flow.execute": async (inputs, block) => {
+      const fb = block;
+      const finalFlowId = this.isInputConnected(fb, "flowId") ? inputs.flowId : fb.data?.flowId;
+      if (finalFlowId === void 0 || finalFlowId === null) {
+        throw new Error(
+          `Missing required input 'flowId' for block type '${block.type}'`
+        );
+      }
+      const execInput = {};
+      for (const [key, value] of Object.entries(
+        inputs
+      )) {
+        if (key === "flowId") {
+          continue;
+        }
+        execInput[key] = value;
+      }
+      const { output } = await this.executeLocally(finalFlowId, execInput);
+      return { output };
+    },
+    "end.custom": async (inputs) => {
+      return { output: { ...inputs } };
+    },
+    // Placeholder implementations for other block types (they will throw errors if used)
+    "start.quickAction.location": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "start.session.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "start.location.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "start.parameter.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "const.number": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "const.text": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "const.boolean": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.add": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.subtract": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.multiply": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.divide": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "map.destructure": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "parameter.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "property.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "location.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "session.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "device.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "user.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "user.create": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "incident.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "parameter.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "device.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "location.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "property.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "session.terminate": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "system.log": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "ui.navigate.screen": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "incident.create": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "control.switch": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.patch": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.get": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.post": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.delete": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.put": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "mqtt.send": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    }
+  };
+  async executeLocally(flowId, context = {}) {
+    const logArray = [];
+    logArray.push({
+      createdAt: /* @__PURE__ */ new Date(),
+      message: `Starting local execution of flow '${flowId}'`,
+      severity: "info"
+    });
+    const flowResponse = await this.retrieve({ flowId });
+    if (!flowResponse.ok) {
+      throw new Error(`Failed to retrieve flow: ${flowResponse.data?.message || "Unknown error"}`);
+    }
+    const flow = flowResponse.data.flow;
+    const blocksById = new Map(
+      flow.nodeArray.map((b) => [b.id, b])
+    );
+    blocksById.set(flow.startNode.id, flow.startNode);
+    const edgeArray = flow.edgeArray;
+    const outputStore = {};
+    const runBlock = async (block) => {
+      logArray.push({
+        createdAt: /* @__PURE__ */ new Date(),
+        message: `Running block ${block.type} (${block.id})`,
+        severity: "info"
+      });
+      const inputs = this.resolveInputs(block, outputStore, edgeArray);
+      const executor = this.blockExecutors[block.type];
+      if (executor === void 0 || executor === null) {
+        throw new Error(`No executor for ${block.type}`);
+      }
+      const raw = await executor(inputs, block, context);
+      const { flowBranch, output } = raw;
+      outputStore[block.id] = output;
+      if (raw.logArray !== void 0) {
+        logArray.push(...raw.logArray);
+      }
+      logArray.push({
+        createdAt: /* @__PURE__ */ new Date(),
+        message: `Block ${block.type} (${block.id}) executed successfully`,
+        severity: "info"
+      });
+      return flowBranch ?? null;
+    };
+    const getNext = (fromId, branch) => {
+      let ce = edgeArray.find(
+        (e) => e.type === "control" && e.from.blockId === fromId && (e.from.output ?? null) === branch
+      );
+      if ((ce === null || ce === void 0) && branch === null) {
+        ce = edgeArray.find(
+          (e) => e.type === "control" && e.from.blockId === fromId
+        );
+      }
+      if (ce === null || ce === void 0) {
+        return null;
+      }
+      return blocksById.get(ce.to.blockId) ?? null;
+    };
+    if (flow.startNode.type.startsWith("start.") === false) {
+      throw new Error(
+        `Flow ${flowId} has an invalid start block that is not of type 'start.'`
+      );
+    }
+    let current = flow.startNode;
+    await runBlock(current);
+    const next = getNext(current.id, null);
+    if (next === null) {
+      return {
+        output: {},
+        logArray
+      };
+    }
+    current = next;
+    while (current.type.startsWith("end.") === false) {
+      const branch = await runBlock(current);
+      const next2 = getNext(current.id, branch);
+      if (next2 === null) {
+        return {
+          output: {},
+          logArray
+        };
+      }
+      current = next2;
+    }
+    await runBlock(current);
+    const endBlock = current;
+    const result = {};
+    const definitions = endBlock.data.outputParamDefinitionArray ?? [];
+    for (const def of definitions) {
+      result[def.name] = outputStore[current.id]?.[def.name] ?? null;
+    }
+    return {
+      output: result,
+      logArray
+    };
+  }
 };
 
 // src/flowTraces/flowTraces.service.ts
@@ -4806,7 +5111,8 @@ var PanelsService = class extends Service {
           name: params.name,
           layoutBlockArray: params.layoutBlockArray,
           highlightLayoutBlockArray: params.highlightLayoutBlockArray,
-          localParameterArray: params.localParameterArray
+          localParameterArray: params.localParameterArray,
+          display: params.display
         },
         authenticationNotOptional: true
       },

package/dist/index.mjs

@@ -3518,6 +3518,7 @@ var EmzService = class extends Service {
 };
 
 // src/flows/flows.service.ts
+import jsonLogic from "json-logic-js";
 var FlowsService = class extends Service {
   constructor(config) {
     super(config);
@@ -3611,6 +3612,310 @@ var FlowsService = class extends Service {
       FlowExecuteOptions
     );
   }
+  areInputsAvailable(block, outputStore, edgeArray) {
+    if (block.in === null || block.in === void 0) {
+      return true;
+    }
+    return Object.values(block.in).every((edgeId) => {
+      const edge = edgeArray.find((e) => e.id === edgeId);
+      if (edge === void 0) {
+        return false;
+      }
+      if (edge.type === "control") {
+        return true;
+      }
+      const srcOutputs = outputStore[edge.from.blockId];
+      return srcOutputs !== null && srcOutputs !== void 0 && edge.from.output in srcOutputs;
+    });
+  }
+  resolveInputs(block, outputStore, edgeArray) {
+    const inputs = {};
+    if (block.in === void 0) {
+      return inputs;
+    }
+    for (const [inputName, edgeId] of Object.entries(block.in)) {
+      const edge = edgeArray.find((e) => e.id === edgeId);
+      if (edge === void 0) {
+        throw new Error(
+          `No edge found with id ${edgeId} for input ${inputName}`
+        );
+      }
+      if (edge.type === "control") {
+        continue;
+      }
+      const srcOutputs = outputStore[edge.from.blockId];
+      if (srcOutputs === void 0 || edge.from.output in srcOutputs === false) {
+        throw new Error(
+          `Missing output '${edge.from.output}' from block '${edge.from.blockId}'`
+        );
+      }
+      inputs[inputName] = srcOutputs[edge.from.output];
+    }
+    return inputs;
+  }
+  isInputConnected(block, inputName) {
+    if (block.in === void 0 || block.in === null) {
+      return false;
+    }
+    return block.in[inputName] !== void 0;
+  }
+  blockExecutors = {
+    "start.custom": async (_inputs, block, context) => {
+      if (block.type !== "start.custom") {
+        throw new Error(
+          `Invalid block type '${block.type}' for start.custom executor`
+        );
+      }
+      const defs = block.data.inputParamDefinitionArray ?? [];
+      if (defs.length === 0) {
+        return { output: {} };
+      }
+      const outputs = {};
+      for (const param of defs) {
+        const value = context[param.name];
+        if (value === void 0 && param.required) {
+          throw new Error(
+            `Missing required input parameter '${param.name}'`
+          );
+        }
+        outputs[param.name] = value;
+      }
+      return {
+        output: outputs
+      };
+    },
+    "control.if": async (inputs, block) => {
+      const fb = block;
+      const result = jsonLogic.apply(fb.data.condition, inputs);
+      return {
+        output: {},
+        flowBranch: result === true ? "true" : "false"
+      };
+    },
+    "flow.execute": async (inputs, block) => {
+      const fb = block;
+      const finalFlowId = this.isInputConnected(fb, "flowId") ? inputs.flowId : fb.data?.flowId;
+      if (finalFlowId === void 0 || finalFlowId === null) {
+        throw new Error(
+          `Missing required input 'flowId' for block type '${block.type}'`
+        );
+      }
+      const execInput = {};
+      for (const [key, value] of Object.entries(
+        inputs
+      )) {
+        if (key === "flowId") {
+          continue;
+        }
+        execInput[key] = value;
+      }
+      const { output } = await this.executeLocally(finalFlowId, execInput);
+      return { output };
+    },
+    "end.custom": async (inputs) => {
+      return { output: { ...inputs } };
+    },
+    // Placeholder implementations for other block types (they will throw errors if used)
+    "start.quickAction.location": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "start.session.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "start.location.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "start.parameter.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "const.number": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "const.text": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "const.boolean": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.add": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.subtract": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.multiply": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "math.divide": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "map.destructure": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "parameter.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "property.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "location.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "session.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "device.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "user.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "user.create": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "incident.retrieve": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "parameter.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "device.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "location.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "property.update": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "session.terminate": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "system.log": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "ui.navigate.screen": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "incident.create": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "control.switch": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.patch": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.get": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.post": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.delete": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "http.put": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    },
+    "mqtt.send": async () => {
+      throw new Error("Block type not implemented in executeLocally");
+    }
+  };
+  async executeLocally(flowId, context = {}) {
+    const logArray = [];
+    logArray.push({
+      createdAt: /* @__PURE__ */ new Date(),
+      message: `Starting local execution of flow '${flowId}'`,
+      severity: "info"
+    });
+    const flowResponse = await this.retrieve({ flowId });
+    if (!flowResponse.ok) {
+      throw new Error(`Failed to retrieve flow: ${flowResponse.data?.message || "Unknown error"}`);
+    }
+    const flow = flowResponse.data.flow;
+    const blocksById = new Map(
+      flow.nodeArray.map((b) => [b.id, b])
+    );
+    blocksById.set(flow.startNode.id, flow.startNode);
+    const edgeArray = flow.edgeArray;
+    const outputStore = {};
+    const runBlock = async (block) => {
+      logArray.push({
+        createdAt: /* @__PURE__ */ new Date(),
+        message: `Running block ${block.type} (${block.id})`,
+        severity: "info"
+      });
+      const inputs = this.resolveInputs(block, outputStore, edgeArray);
+      const executor = this.blockExecutors[block.type];
+      if (executor === void 0 || executor === null) {
+        throw new Error(`No executor for ${block.type}`);
+      }
+      const raw = await executor(inputs, block, context);
+      const { flowBranch, output } = raw;
+      outputStore[block.id] = output;
+      if (raw.logArray !== void 0) {
+        logArray.push(...raw.logArray);
+      }
+      logArray.push({
+        createdAt: /* @__PURE__ */ new Date(),
+        message: `Block ${block.type} (${block.id}) executed successfully`,
+        severity: "info"
+      });
+      return flowBranch ?? null;
+    };
+    const getNext = (fromId, branch) => {
+      let ce = edgeArray.find(
+        (e) => e.type === "control" && e.from.blockId === fromId && (e.from.output ?? null) === branch
+      );
+      if ((ce === null || ce === void 0) && branch === null) {
+        ce = edgeArray.find(
+          (e) => e.type === "control" && e.from.blockId === fromId
+        );
+      }
+      if (ce === null || ce === void 0) {
+        return null;
+      }
+      return blocksById.get(ce.to.blockId) ?? null;
+    };
+    if (flow.startNode.type.startsWith("start.") === false) {
+      throw new Error(
+        `Flow ${flowId} has an invalid start block that is not of type 'start.'`
+      );
+    }
+    let current = flow.startNode;
+    await runBlock(current);
+    const next = getNext(current.id, null);
+    if (next === null) {
+      return {
+        output: {},
+        logArray
+      };
+    }
+    current = next;
+    while (current.type.startsWith("end.") === false) {
+      const branch = await runBlock(current);
+      const next2 = getNext(current.id, branch);
+      if (next2 === null) {
+        return {
+          output: {},
+          logArray
+        };
+      }
+      current = next2;
+    }
+    await runBlock(current);
+    const endBlock = current;
+    const result = {};
+    const definitions = endBlock.data.outputParamDefinitionArray ?? [];
+    for (const def of definitions) {
+      result[def.name] = outputStore[current.id]?.[def.name] ?? null;
+    }
+    return {
+      output: result,
+      logArray
+    };
+  }
 };
 
 // src/flowTraces/flowTraces.service.ts
@@ -4762,7 +5067,8 @@ var PanelsService = class extends Service {
           name: params.name,
           layoutBlockArray: params.layoutBlockArray,
           highlightLayoutBlockArray: params.highlightLayoutBlockArray,
-          localParameterArray: params.localParameterArray
+          localParameterArray: params.localParameterArray,
+          display: params.display
         },
         authenticationNotOptional: true
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juhuu/sdk-ts",
-  "version": "1.2.263",
+  "version": "1.2.265",
   "description": "Typescript wrapper for JUHUU services",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -26,11 +26,13 @@
   ],
   "homepage": "https://github.com/JUHUU-Labs/sdk-ts#readme",
   "devDependencies": {
+    "@types/json-logic-js": "^2.0.8",
     "tsup": "^8.0.2",
     "typescript": "^5.4.5"
   },
   "dependencies": {
     "@types/node": "^24.1.0",
+    "json-logic-js": "^2.0.5",
     "socket.io-client": "^4.7.5"
   }
 }