@requence/service 1.0.0-alpha.0 → 1.0.0-alpha.2

package/build/index.js

@@ -1,19 +1,28 @@
 import {
-clone,
-createObjectProxy,
-deobfuscate,
-obfuscate
-} from "./chunk-2exhyr7n.js";
+  clone,
+  createObjectProxy,
+  deobfuscate,
+  obfuscate
+} from "./chunk-0x9092n4.js";
 
 // src/index.ts
-import {readFileSync} from "node:fs";
-import {z as z8} from "zod";
+import { readFileSync } from "node:fs";
+import { z as z8 } from "zod";
 
 // ../helpers/src/context/context.ts
-import {z} from "zod";
+import { z } from "zod";
+var contextSchema = z.object({
+  input: z.any(),
+  meta: z.any(),
+  tenant: z.object({ name: z.string() }),
+  data: z.record(z.string(), z.any()),
+  errors: z.record(z.string(), z.string()),
+  dates: z.record(z.string(), z.string().datetime())
+});
 function isRecord(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
+var internalKey = Symbol.for("internal");
 function getInternalContext(contextHelper) {
   return contextHelper[internalKey];
 }
@@ -53,9 +62,6 @@ function createContextHelper(context, nodes) {
     getInput() {
       return context.input;
     },
-    getTenantName() {
-      return context.tenant.name;
-    },
     getMeta() {
       return context.meta;
     },
@@ -87,24 +93,16 @@ function createContextHelper(context, nodes) {
       if (!nodeIds) {
         return null;
       }
-      return nodeIds.map((nodeId) => results.get(nodeId)?.error).filter((str) => typeof str === "string").join("\n");
+      return nodeIds.map((nodeId) => results.get(nodeId)?.error).filter((str) => typeof str === "string").join(`
+`);
     }
   };
 }
-var contextSchema = z.object({
-  input: z.any(),
-  meta: z.any(),
-  tenant: z.object({ name: z.string() }),
-  data: z.record(z.string(), z.any()),
-  errors: z.record(z.string(), z.string()),
-  dates: z.record(z.string(), z.string().datetime())
-});
-var internalKey = Symbol.for("internal");
 // ../helpers/src/protocol/command.ts
-import {z as z5} from "zod";
+import { z as z5 } from "zod";
 
 // ../helpers/src/protocol/nodes.ts
-import {ZodError, z as z4} from "zod";
+import { ZodError, z as z4 } from "zod";
 
 // ../helpers/src/protocol/getNodeOutputs.ts
 function getNodeOutputs(node, outputName) {
@@ -240,10 +238,10 @@ function identifyNode(nodeId, getNode) {
 }
 
 // ../helpers/src/protocol/node.ts
-import {z as z3} from "zod";
+import { z as z3 } from "zod";
 
 // ../helpers/src/protocol/jsonSchema.ts
-import {z as z2} from "zod";
+import { z as z2 } from "zod";
 var jsonSchema7Schema = z2.lazy(() => z2.object({
   $id: z2.string().optional(),
   $schema: z2.string().optional(),
@@ -306,37 +304,6 @@ var jsonSchema7ObjectSchema = z2.object({
 });
 
 // ../helpers/src/protocol/node.ts
-function validateOutputs(outputs, ctx) {
-  const exitOutputs = new Set(outputs.filter((output) => output.exit).map((output) => output.default ? "__default__" : output.name));
-  outputs.filter((output) => !output.exit).forEach((output) => {
-    const name = output.default ? "__default__" : output.name;
-    if (exitOutputs.has(name)) {
-      ctx.addIssue({
-        code: "custom",
-        message: output.default ? `default exit output cannot be mixed with target output "${output.target}"` : `named exit output "${name}" cannot be mixed with target output "${output.target}"`
-      });
-    }
-  });
-  const targets = new Map;
-  outputs.forEach((output) => {
-    const name = output.default ? "__default__" : output.name;
-    const target = output.exit ? "__exit__" : output.target;
-    if (!targets.has(name)) {
-      targets.set(name, new Set);
-    }
-    const knownTargets = targets.get(name);
-    if (knownTargets.has(target)) {
-      ctx.addIssue({
-        code: "custom",
-        message: [
-          output.default ? "duplicate default output" : `duplicate named output "${name}"`,
-          output.exit ? "for exit" : `for target "${target}"`
-        ].join(" ")
-      });
-    }
-    knownTargets.add(target);
-  });
-}
 var outputDefinitionSchema = z3.object({
   schema: jsonSchema7Schema.nullable().optional()
 }).and(z3.union([
@@ -382,6 +349,37 @@ var outputSchema = z3.union([z3.string().min(1), outputDefinitionSchema]).transf
   }
   return output;
 });
+function validateOutputs(outputs, ctx) {
+  const exitOutputs = new Set(outputs.filter((output) => output.exit).map((output) => output.default ? "__default__" : output.name));
+  outputs.filter((output) => !output.exit).forEach((output) => {
+    const name = output.default ? "__default__" : output.name;
+    if (exitOutputs.has(name)) {
+      ctx.addIssue({
+        code: "custom",
+        message: output.default ? `default exit output cannot be mixed with target output "${output.target}"` : `named exit output "${name}" cannot be mixed with target output "${output.target}"`
+      });
+    }
+  });
+  const targets = new Map;
+  outputs.forEach((output) => {
+    const name = output.default ? "__default__" : output.name;
+    const target = output.exit ? "__exit__" : output.target;
+    if (!targets.has(name)) {
+      targets.set(name, new Set);
+    }
+    const knownTargets = targets.get(name);
+    if (knownTargets.has(target)) {
+      ctx.addIssue({
+        code: "custom",
+        message: [
+          output.default ? "duplicate default output" : `duplicate named output "${name}"`,
+          output.exit ? "for exit" : `for target "${target}"`
+        ].join(" ")
+      });
+    }
+    knownTargets.add(target);
+  });
+}
 var defaultOutputsSchema = z3.array(defaultOutputSchema).default([]).superRefine(validateOutputs);
 var outputsSchema = z3.array(outputSchema).default([]).superRefine(validateOutputs);
 var idSchema = z3.string().uuid().default(() => crypto.randomUUID());
@@ -400,8 +398,9 @@ var serviceNodeSchema = z3.object({
   inputSchema: jsonSchema7ObjectSchema.nullable().optional(),
   id: idSchema,
   name: z3.string(),
-  version: z3.string().default("*"),
+  version: z3.string(),
   configuration: z3.any().optional(),
+  configurationSchema: jsonSchema7Schema.nullable().optional(),
   alias: z3.string().optional(),
   ttl: z3.number().int().min(1).optional(),
   retry: z3.number().int().min(1).optional(),
@@ -460,24 +459,24 @@ var nodesSchema = z4.array(nodeSchema).transform((nodes) => {
   const names = new Map;
   let entryNode = null;
   let firstNodeId = null;
-  for (const node2 of nodes) {
-    if (node2.type === "entry") {
-      entryNode = node2;
+  for (const node of nodes) {
+    if (node.type === "entry") {
+      entryNode = node;
     }
-    if ((node2.type === "service" || node2.type === "logic") && !firstNodeId) {
-      firstNodeId = node2.id;
+    if ((node.type === "service" || node.type === "logic") && !firstNodeId) {
+      firstNodeId = node.id;
     }
-    if ("alias" in node2 && node2.alias) {
-      if (!aliases.has(node2.alias)) {
-        aliases.set(node2.alias, []);
+    if ("alias" in node && node.alias) {
+      if (!aliases.has(node.alias)) {
+        aliases.set(node.alias, []);
       }
-      aliases.get(node2.alias).push(node2.id);
+      aliases.get(node.alias).push(node.id);
     }
-    if ("name" in node2 && node2.name) {
-      if (!names.has(node2.name)) {
-        names.set(node2.name, []);
+    if ("name" in node && node.name) {
+      if (!names.has(node.name)) {
+        names.set(node.name, []);
       }
-      names.get(node2.name).push(node2.id);
+      names.get(node.name).push(node.id);
     }
   }
   if (!entryNode && firstNodeId) {
@@ -496,15 +495,15 @@ var nodesSchema = z4.array(nodeSchema).transform((nodes) => {
     }
     return identifier;
   };
-  return nodes.map((node2) => {
-    node2.output = node2.output.map((output) => ("target" in output) ? {
+  return nodes.map((node) => {
+    node.output = node.output.map((output) => ("target" in output) ? {
       ...output,
       target: resolveOutput(output.target)
     } : output);
-    if ("subject" in node2) {
-      node2.subject = resolveOutput(node2.subject);
+    if ("subject" in node) {
+      node.subject = resolveOutput(node.subject);
     }
-    return node2;
+    return node;
   });
 }).transform((nodes) => {
   const { getInputs, getNode } = createNodeMaps(nodes);
@@ -512,28 +511,28 @@ var nodesSchema = z4.array(nodeSchema).transform((nodes) => {
   const nodeIds = new Set;
   const catchSubjects = new Map;
   const identify = (nodeId) => identifyNode(nodeId, getNode);
-  for (const node2 of nodes) {
-    if (nodeIds.has(node2.id)) {
+  for (const node of nodes) {
+    if (nodeIds.has(node.id)) {
       throw new NodesError("id is not unique", {
-        id: node2.id
+        id: node.id
       });
     }
-    nodeIds.add(node2.id);
-    if ("alias" in node2 && node2.alias) {
-      if (nodeAliases.has(node2.alias)) {
+    nodeIds.add(node.id);
+    if ("alias" in node && node.alias) {
+      if (nodeAliases.has(node.alias)) {
         throw new NodesError("alias is not unique", {
-          alias: node2.alias
+          alias: node.alias
         });
       }
-      nodeAliases.add(node2.alias);
+      nodeAliases.add(node.alias);
     }
-    if (node2.type === "catch") {
-      if (catchSubjects.has(node2.subject)) {
+    if (node.type === "catch") {
+      if (catchSubjects.has(node.subject)) {
         throw new NodesError("only one catch node per service allowed", {
-          id: node2.subject
+          id: node.subject
         });
       }
-      catchSubjects.set(node2.subject, node2);
+      catchSubjects.set(node.subject, node);
     }
   }
   if (!getNode("__entry__")) {
@@ -542,21 +541,21 @@ var nodesSchema = z4.array(nodeSchema).transform((nodes) => {
   if (getInputs("__exit__").length === 0) {
     throw new NodesError("no path leads to exit");
   }
-  for (const catchNode of nodes.filter((node2) => node2.type === "catch")) {
+  for (const catchNode of nodes.filter((node) => node.type === "catch")) {
     if (!getNode(catchNode.subject)) {
       throw new NodesError("catch node has invalid subject", {
         id: catchNode.subject
       });
     }
   }
-  for (const node2 of nodes) {
-    if (node2.type === "or") {
-      const inputs = getInputs(node2);
+  for (const node of nodes) {
+    if (node.type === "or") {
+      const inputs = getInputs(node);
       if (!inputs || inputs.length < 2) {
         throw new NodesError("or nodes need at least 2 inputs");
       }
     }
-    for (const targetNodeId of getNodeOutputs(node2)) {
+    for (const targetNodeId of getNodeOutputs(node)) {
       if (targetNodeId !== "__exit__" && !getNode(targetNodeId)) {
         throw new NodesError("missing node", {
           id: targetNodeId
@@ -578,8 +577,8 @@ var nodesSchema = z4.array(nodeSchema).transform((nodes) => {
   }
   for (const possiblePath of possiblePaths) {
     for (const pathSegment of possiblePath) {
-      const node2 = pathSegment === "__exit__" ? null : getNode(pathSegment);
-      if (node2?.type === "catch" && possiblePath.includes(node2.subject)) {
+      const node = pathSegment === "__exit__" ? null : getNode(pathSegment);
+      if (node?.type === "catch" && possiblePath.includes(node.subject)) {
         throw new NodesError("Unresolvable, inputs needs both catch and subject", {
           path: possiblePath.map(identify)
         });
@@ -606,7 +605,7 @@ var createNodesSchema = z5.object({
 });
 var commandSchema = z5.union([abortSchema, createNodesSchema]);
 // ../helpers/src/protocol/update.ts
-import {z as z6} from "zod";
+import { z as z6 } from "zod";
 var baseUpdateSchema = z6.object({
   timestamp: z6.number().int().transform((int) => new Date(int))
 });
@@ -668,22 +667,11 @@ var updateSchema = z6.discriminatedUnion("type", [
   taskErrorUpdateSchema,
   taskFinishedUpdateSchema
 ]);
-// src/connections/createAmqpConnection.ts
-import {connect} from "amqp-connection-manager";
-import semver from "semver";
-import {z as z7} from "zod";
+// src/createAmqpConnection.ts
+import { connect } from "amqp-connection-manager";
+import { z as z7 } from "zod";
 
 // src/helpers.ts
-function isOutputValue(value) {
-  return value !== null && typeof value === "object" && OUTPUT_VALUE in value;
-}
-function unwrapResult(result) {
-  if (isOutputValue(result)) {
-    return { value: result.value, outputName: result[OUTPUT_VALUE] };
-  }
-  return { value: result, outputName: null };
-}
-
 class RetryError extends Error {
   delay;
   constructor(delay) {
@@ -695,6 +683,15 @@ class RetryError extends Error {
 class AbortError extends Error {
 }
 var OUTPUT_VALUE = Symbol("output_value");
+function isOutputValue(value) {
+  return value !== null && typeof value === "object" && OUTPUT_VALUE in value;
+}
+function unwrapResult(result) {
+  if (isOutputValue(result)) {
+    return { value: result.value, outputName: result[OUTPUT_VALUE] };
+  }
+  return { value: result, outputName: null };
+}
 function createExtendedContextHelper(options) {
   const contextHelper = createContextHelper(options.context, options.nodes);
   const internalContext = getInternalContext(contextHelper);
@@ -741,10 +738,7 @@ function createExtendedContextHelper(options) {
   });
 }
 
-// src/connections/createAmqpConnection.ts
-function isMessageHandlerGenerator(handler) {
-  return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
-}
+// src/createAmqpConnection.ts
 var messageKeySchema = z7.string().transform((str) => deobfuscate(str)).pipe(z7.array(z7.string().uuid()).length(3)).transform((arr) => ({
   taskId: arr[0],
   serviceId: arr[1],
@@ -772,6 +766,9 @@ var payloadSchema = z7.object({ content: z7.instanceof(Buffer) }).transform((msg
     state: z7.record(z7.any())
   })
 }));
+function isMessageHandlerGenerator(handler) {
+  return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
+}
 var activeMessages = new Set;
 function createConnection({
   url,
@@ -780,7 +777,7 @@ function createConnection({
   silent = false,
   connectionTimeout
 }, messageHandler) {
-  const queue = url.username;
+  const queue = `${url.username}@${version}`;
   const exchange = url.username;
   const connection = connect(url.toString());
   const connectedPromise = new Promise((resolve, reject) => {
@@ -836,36 +833,9 @@ function createConnection({
     try {
       let deferred = false;
       let deferredReason = null;
-      const {
-        messageId,
-        serviceId,
-        taskId,
-        version: expectedVersion
-      } = headerSchema.parse(message);
+      const { messageId, serviceId, taskId } = headerSchema.parse(message);
       activeMessages.add(messageId);
       removeActiveMessage = () => activeMessages.delete(messageId);
-      if (!semver.satisfies(version, expectedVersion)) {
-        let expirationDate = message.properties.headers?.["original-expiration-date"] ?? null;
-        if (!expirationDate && message.properties.expiration) {
-          expirationDate = String(Date.now() + parseInt(message.properties.expiration));
-        }
-        if (expirationDate && Date.now() > parseInt(expirationDate)) {
-          channel.nack(message, false, false);
-          return;
-        }
-        const properties = {
-          ...message.properties,
-          headers: {
-            ...message.properties.headers,
-            "version-mismatch": version,
-            "original-expiration-date": expirationDate
-          },
-          expiration: 0
-        };
-        channel.publish(`${exchange}-retry`, "retry", message.content, properties);
-        channel.ack(message);
-        return;
-      }
       const payload = payloadSchema.parse(message);
       let acked = false;
       const ack = () => {
@@ -920,13 +890,15 @@ function createConnection({
             console.warn("returning a value in a deferred message resets the deferred status");
           }
           const { value, outputName } = unwrapResult(result);
-          publish({
-            messageId,
-            taskId,
-            serviceId,
-            data: value,
-            outputName
-          });
+          if (!done || typeof value !== "undefined") {
+            publish({
+              messageId,
+              taskId,
+              serviceId,
+              data: value,
+              outputName
+            });
+          }
           if (done) {
             break;
           }
@@ -949,14 +921,14 @@ function createConnection({
           });
         }
       }
-      publish({
+      setImmediate(() => publish({
         messageId,
         taskId,
         serviceId,
         data: deferredReason,
         deferred,
         done: !deferred
-      });
+      }));
     } catch (error) {
       if (error instanceof RetryError) {
         const properties = {
@@ -1005,61 +977,63 @@ function createConnection({
     }
   });
   const api = {
-    close: () => channel.close(),
-    open: () => connectedPromise.then(() => api),
-    sendToOutput(messageKey, outputName, data) {
-      const { taskId, serviceId, messageId } = messageKeySchema.parse(messageKey);
-      if (activeMessages.has(messageId)) {
-        throw new Error("Cannot send deferred message while callback handler is still running");
-      }
-      publish({
-        messageId,
-        taskId,
-        serviceId,
-        data,
-        outputName
-      });
+    close: async () => {
+      await channel.close();
+      await connection.close();
     },
-    send(messageKey, data) {
-      const { taskId, serviceId, messageId } = messageKeySchema.parse(messageKey);
-      if (activeMessages.has(messageId)) {
-        throw new Error("Cannot send deferred message while callback handler is still running");
-      }
-      publish({
-        messageId,
-        taskId,
-        serviceId,
-        data
+    open: () => connectedPromise.then(() => api),
+    async act(messageKey, actor) {
+      await actor({
+        sendToOutput(outputName, data) {
+          const { taskId: taskId2, serviceId: serviceId2, messageId: messageId2 } = messageKeySchema.parse(messageKey);
+          if (activeMessages.has(messageId2)) {
+            throw new Error("Cannot send deferred message while callback handler is still running");
+          }
+          publish({
+            messageId: messageId2,
+            taskId: taskId2,
+            serviceId: serviceId2,
+            data,
+            outputName
+          });
+        },
+        send(data) {
+          const { taskId: taskId2, serviceId: serviceId2, messageId: messageId2 } = messageKeySchema.parse(messageKey);
+          if (activeMessages.has(messageId2)) {
+            throw new Error("Cannot send deferred message while callback handler is still running");
+          }
+          publish({
+            messageId: messageId2,
+            taskId: taskId2,
+            serviceId: serviceId2,
+            data
+          });
+        },
+        abort(error) {
+          const { taskId: taskId2, serviceId: serviceId2, messageId: messageId2 } = messageKeySchema.parse(messageKey);
+          if (activeMessages.has(messageId2)) {
+            throw new Error("Cannot send deferred message while callback handler is still running");
+          }
+          channel.publish(`${exchange}-retry`, "requeue", error instanceof Error ? error.message : error, {
+            correlationId: messageId2,
+            expiration: 0,
+            priority: 0,
+            contentType: "text/plain",
+            headers: {
+              taskId: taskId2,
+              serviceId: serviceId2,
+              abort: true
+            }
+          });
+        }
       });
-    },
-    end(messageKey) {
       const { taskId, serviceId, messageId } = messageKeySchema.parse(messageKey);
-      if (activeMessages.has(messageId)) {
-        throw new Error("Cannot send deferred message while callback handler is still running");
-      }
-      publish({
+      setImmediate(() => publish({
         messageId,
         taskId,
         serviceId,
         done: true
-      });
-    },
-    abort(messageKey, error) {
-      const { taskId, serviceId, messageId } = messageKeySchema.parse(messageKey);
-      if (activeMessages.has(messageId)) {
-        throw new Error("Cannot send deferred message while callback handler is still running");
-      }
-      channel.publish(`${exchange}-retry`, "requeue", error instanceof Error ? error.message : error, {
-        correlationId: messageId,
-        expiration: 0,
-        priority: 0,
-        contentType: "text/plain",
-        headers: {
-          taskId,
-          serviceId,
-          abort: true
-        }
-      });
+      }));
     }
   };
   return api;
@@ -1091,7 +1065,7 @@ function createService(optionsOrVersion, optionalMessageHandler) {
   }
   const key = options.serviceKey ?? process.env.REQUENCE_SERVICE_KEY ?? JSON.parse(readFileSync("package.json", "utf-8")).requence?.serviceKey;
   if (!key) {
-    throw Error("No service key found");
+    throw new Error("No service key found");
   }
   const parts = deobfuscate(key);
   if (parts.length < 2 || parts[0] !== "service") {
@@ -1107,5 +1081,5 @@ export {
   createService as default
 };
 
-//# debugId=C7AD515DE676451264756E2164756E21
+//# debugId=8A6F0759E8DF605064756E2164756E21
 //# sourceMappingURL=index.js.map