@juhuu/sdk-ts 1.2.273 → 1.2.274

package/dist/index.d.mts

@@ -1708,10 +1708,7 @@ declare class FlowsService extends Service {
     private resolveInputs;
     private isInputConnected;
     private blockExecutors;
-    executeLocally(FlowExecuteLocallyParams: JUHUU.Flow.ExecuteLocally.Params, FlowExecuteLocallyOptions?: JUHUU.Flow.Execute.Options): Promise<{
-        output: Record<string, any>;
-        logArray: FlowLog[];
-    }>;
+    executeLocally(FlowExecuteLocallyParams: JUHUU.Flow.ExecuteLocally.Params, FlowExecuteLocallyOptions?: JUHUU.Flow.ExecuteLocally.Options): Promise<JUHUU.Flow.ExecuteLocally.Response>;
 }
 
 declare class FlowTracesService extends Service {

package/dist/index.d.ts

@@ -1708,10 +1708,7 @@ declare class FlowsService extends Service {
     private resolveInputs;
     private isInputConnected;
     private blockExecutors;
-    executeLocally(FlowExecuteLocallyParams: JUHUU.Flow.ExecuteLocally.Params, FlowExecuteLocallyOptions?: JUHUU.Flow.Execute.Options): Promise<{
-        output: Record<string, any>;
-        logArray: FlowLog[];
-    }>;
+    executeLocally(FlowExecuteLocallyParams: JUHUU.Flow.ExecuteLocally.Params, FlowExecuteLocallyOptions?: JUHUU.Flow.ExecuteLocally.Options): Promise<JUHUU.Flow.ExecuteLocally.Response>;
 }
 
 declare class FlowTracesService extends Service {

package/dist/index.js

@@ -3787,119 +3787,27 @@ var FlowsService = class extends Service {
         flowId: finalFlowId,
         input: execInput
       });
-      if (!response.ok) {
-        throw new Error(`Failed to execute flow: ${response.data?.message || "Unknown error"}`);
+      if (response.ok === false) {
+        throw new Error(
+          `Failed to execute flow: ${response.data?.message || "Unknown error"}`
+        );
       }
       return { output: response.data.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");
+    "const.number": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     },
-    "device.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "const.text": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     },
-    "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");
+    "const.boolean": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     }
   };
   async executeLocally(FlowExecuteLocallyParams, FlowExecuteLocallyOptions) {
@@ -3909,100 +3817,114 @@ var FlowsService = class extends Service {
       message: `Starting local execution of flow '${FlowExecuteLocallyParams.flowId}'`,
       severity: "info"
     });
-    const flowResponse = await this.retrieve({
-      flowId: FlowExecuteLocallyParams.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"
+    try {
+      const flowResponse = await this.retrieve({
+        flowId: FlowExecuteLocallyParams.flowId
       });
-      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}`);
+      if (!flowResponse.ok) {
+        throw new Error(
+          `Failed to retrieve flow: ${flowResponse.data?.message || "Unknown error"}`
+        );
       }
-      const raw = await executor(
-        inputs,
-        block,
-        FlowExecuteLocallyParams.input ?? {}
+      const flow = flowResponse.data.flow;
+      const blocksById = new Map(
+        flow.nodeArray.map((b) => [b.id, b])
       );
-      const { flowBranch, output } = raw;
-      outputStore[block.id] = output;
-      if (raw.logArray !== void 0) {
-        logArray.push(...raw.logArray);
+      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(
+            `Block type '${block.type}' is not implemented in the local executor`
+          );
+        }
+        const raw = await executor(
+          inputs,
+          block,
+          FlowExecuteLocallyParams.input ?? {}
+        );
+        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 ${FlowExecuteLocallyParams.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
+      };
+    } catch (error) {
       logArray.push({
         createdAt: /* @__PURE__ */ new Date(),
-        message: `Block ${block.type} (${block.id}) executed successfully`,
-        severity: "info"
+        message: `Flow execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        severity: "error"
       });
-      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 ${FlowExecuteLocallyParams.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
-    };
   }
 };
 

package/dist/index.mjs

@@ -3743,119 +3743,27 @@ var FlowsService = class extends Service {
         flowId: finalFlowId,
         input: execInput
       });
-      if (!response.ok) {
-        throw new Error(`Failed to execute flow: ${response.data?.message || "Unknown error"}`);
+      if (response.ok === false) {
+        throw new Error(
+          `Failed to execute flow: ${response.data?.message || "Unknown error"}`
+        );
       }
       return { output: response.data.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");
+    "const.number": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     },
-    "device.update": async () => {
-      throw new Error("Block type not implemented in executeLocally");
+    "const.text": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     },
-    "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");
+    "const.boolean": async (_inputs, block) => {
+      const { data } = block;
+      return { output: { value: data?.value } };
     }
   };
   async executeLocally(FlowExecuteLocallyParams, FlowExecuteLocallyOptions) {
@@ -3865,100 +3773,114 @@ var FlowsService = class extends Service {
       message: `Starting local execution of flow '${FlowExecuteLocallyParams.flowId}'`,
       severity: "info"
     });
-    const flowResponse = await this.retrieve({
-      flowId: FlowExecuteLocallyParams.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"
+    try {
+      const flowResponse = await this.retrieve({
+        flowId: FlowExecuteLocallyParams.flowId
       });
-      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}`);
+      if (!flowResponse.ok) {
+        throw new Error(
+          `Failed to retrieve flow: ${flowResponse.data?.message || "Unknown error"}`
+        );
       }
-      const raw = await executor(
-        inputs,
-        block,
-        FlowExecuteLocallyParams.input ?? {}
+      const flow = flowResponse.data.flow;
+      const blocksById = new Map(
+        flow.nodeArray.map((b) => [b.id, b])
       );
-      const { flowBranch, output } = raw;
-      outputStore[block.id] = output;
-      if (raw.logArray !== void 0) {
-        logArray.push(...raw.logArray);
+      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(
+            `Block type '${block.type}' is not implemented in the local executor`
+          );
+        }
+        const raw = await executor(
+          inputs,
+          block,
+          FlowExecuteLocallyParams.input ?? {}
+        );
+        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 ${FlowExecuteLocallyParams.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
+      };
+    } catch (error) {
       logArray.push({
         createdAt: /* @__PURE__ */ new Date(),
-        message: `Block ${block.type} (${block.id}) executed successfully`,
-        severity: "info"
+        message: `Flow execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        severity: "error"
       });
-      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 ${FlowExecuteLocallyParams.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
-    };
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juhuu/sdk-ts",
-  "version": "1.2.273",
+  "version": "1.2.274",
   "description": "Typescript wrapper for JUHUU services",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",