@requence/service 1.0.0-alpha.0

package/build/index.js

@@ -0,0 +1,1111 @@
+import {
+clone,
+createObjectProxy,
+deobfuscate,
+obfuscate
+} from "./chunk-2exhyr7n.js";
+
+// src/index.ts
+import {readFileSync} from "node:fs";
+import {z as z8} from "zod";
+
+// ../helpers/src/context/context.ts
+import {z} from "zod";
+function isRecord(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+function getInternalContext(contextHelper) {
+  return contextHelper[internalKey];
+}
+function createContextHelper(context, nodes) {
+  const results = new Map(nodes.map((node) => [
+    node.id,
+    {
+      node,
+      executionDate: node.id in context.dates ? new Date(context.dates[node.id]) : null,
+      data: context.data[node.id] ?? null,
+      error: context.errors[node.id] ?? null
+    }
+  ]));
+  const lookUpMap = new Map;
+  for (const node of nodes) {
+    const alias = typeof node.meta?.mapAlias === "string" ? node.meta.mapAlias : ("alias" in node) && node.alias;
+    if (alias) {
+      if (lookUpMap.has(alias)) {
+        lookUpMap.get(alias).push(node.id);
+      } else {
+        lookUpMap.set(alias, [node.id]);
+      }
+    }
+    const name = typeof node.meta?.mapName === "string" ? node.meta.mapName : node.type === "service" && node.name;
+    if (name) {
+      if (lookUpMap.has(name)) {
+        lookUpMap.get(name).push(node.id);
+      } else {
+        lookUpMap.set(name, [node.id]);
+      }
+    }
+  }
+  return {
+    [internalKey]: {
+      results
+    },
+    getInput() {
+      return context.input;
+    },
+    getTenantName() {
+      return context.tenant.name;
+    },
+    getMeta() {
+      return context.meta;
+    },
+    getData(alias) {
+      if (alias) {
+        const nodeIds = lookUpMap.get(alias);
+        if (!nodeIds) {
+          return null;
+        }
+        const combinedData = nodeIds.map((nodeId) => results.get(nodeId)?.data).filter(Boolean);
+        if (combinedData.length === 0) {
+          return null;
+        }
+        if (combinedData.length === 1) {
+          return combinedData[0];
+        }
+        if (combinedData.every(isRecord)) {
+          return combinedData.reduce((acc, data) => ({ ...acc, ...data }), {});
+        }
+        return combinedData;
+      }
+      return Array.from(results.values()).filter((result) => result.executionDate && isRecord(result.data)).toSorted((a, b) => a.executionDate.getTime() - b.executionDate.getTime()).reduce((acc, result) => ({
+        ...acc,
+        ...result.data
+      }), isRecord(context.input) ? { ...context.input } : {});
+    },
+    getError(alias) {
+      const nodeIds = lookUpMap.get(alias);
+      if (!nodeIds) {
+        return null;
+      }
+      return nodeIds.map((nodeId) => results.get(nodeId)?.error).filter((str) => typeof str === "string").join("\n");
+    }
+  };
+}
+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";
+
+// ../helpers/src/protocol/nodes.ts
+import {ZodError, z as z4} from "zod";
+
+// ../helpers/src/protocol/getNodeOutputs.ts
+function getNodeOutputs(node, outputName) {
+  const outputs = !outputName ? node.output : outputName === "__default__" ? node.output.filter((o) => o.default) : node.output.filter((o) => ("name" in o) && o.name === outputName);
+  const outputTargets = new Set;
+  for (const output of outputs) {
+    if (output.exit) {
+      outputTargets.add("__exit__");
+    } else {
+      outputTargets.add(output.target);
+    }
+  }
+  return Array.from(outputTargets);
+}
+
+// ../helpers/src/protocol/createNodeMaps.ts
+function createNodeMaps(nodes) {
+  const nodesByIdMap = new Map;
+  const nodesByNameOrAlias = new Map;
+  const inputsNodeMap = new Map([
+    ["__exit__", []]
+  ]);
+  for (const node of nodes) {
+    nodesByIdMap.set(node.id, node);
+    if ("alias" in node && node.alias) {
+      nodesByNameOrAlias.set(node.alias, node);
+    }
+    if ("name" in node && node.name) {
+      nodesByNameOrAlias.set(node.name, node);
+    }
+  }
+  for (const node of nodes) {
+    for (const outputNodeId of getNodeOutputs(node)) {
+      if (!inputsNodeMap.has(outputNodeId)) {
+        inputsNodeMap.set(outputNodeId, []);
+      }
+      inputsNodeMap.get(outputNodeId).push(node);
+    }
+  }
+  return {
+    getInputs(node) {
+      if (typeof node === "string") {
+        return inputsNodeMap.get(node) ?? [];
+      }
+      if (node.type === "catch" || node.type === "entry") {
+        return [];
+      }
+      return inputsNodeMap.get(node.id) ?? [];
+    },
+    getNode(nodeId) {
+      return nodesByIdMap.get(nodeId);
+    },
+    lookupNode(nameOrAlias) {
+      return nodesByNameOrAlias.get(nameOrAlias);
+    }
+  };
+}
+
+// ../helpers/src/protocol/getPossiblePaths.ts
+function getPossiblePaths({
+  getInputs,
+  getNode,
+  onMissingInputs
+}) {
+  const sets = new Set;
+  const followPath = (nodeId, set2) => {
+    if (nodeId === "__entry__") {
+      return;
+    }
+    const node = nodeId !== "__exit__" ? getNode(nodeId) : null;
+    const isOrNode = node?.type === "or";
+    const inputNodes = getInputs(nodeId);
+    if (node && node.type !== "catch" && inputNodes.length === 0) {
+      onMissingInputs?.(node, Array.from(set2).toReversed());
+    }
+    for (const inputNode of inputNodes) {
+      let usedSet = set2;
+      if (isOrNode) {
+        usedSet = new Set(set2);
+        sets.add(usedSet);
+      }
+      const inputNodeId = inputNode.id;
+      if (inputNode.type !== "or") {
+        if (usedSet.has(inputNodeId)) {
+          return;
+        }
+        usedSet.add(inputNodeId);
+      }
+      followPath(inputNodeId, usedSet);
+    }
+    if (isOrNode) {
+      sets.delete(set2);
+    }
+  };
+  const set = new Set(["__exit__"]);
+  sets.add(set);
+  followPath("__exit__", set);
+  return Array.from(sets, (set2) => Array.from(set2).toReversed());
+}
+
+// ../helpers/src/protocol/identifyNode.ts
+function identifyNode(nodeId, getNode) {
+  if (nodeId === "__entry__") {
+    return "ENTRY";
+  }
+  if (nodeId === "__exit__") {
+    return "EXIT";
+  }
+  if (typeof nodeId === "symbol") {
+    return String(nodeId);
+  }
+  const node = getNode(nodeId);
+  if (!node) {
+    return `Unknown[${nodeId}]`;
+  }
+  switch (node.type) {
+    case "service": {
+      return `Service[${node.alias || node.name}]`;
+    }
+    case "catch": {
+      return `Catch[${identifyNode(node.subject, getNode)}]`;
+    }
+    case "logic": {
+      return `Logic[${node.alias || node.id}]`;
+    }
+    case "entry": {
+      return "ENTRY";
+    }
+    case "or": {
+      return `OR[${node.alias || node.id}]`;
+    }
+  }
+}
+
+// ../helpers/src/protocol/node.ts
+import {z as z3} from "zod";
+
+// ../helpers/src/protocol/jsonSchema.ts
+import {z as z2} from "zod";
+var jsonSchema7Schema = z2.lazy(() => z2.object({
+  $id: z2.string().optional(),
+  $schema: z2.string().optional(),
+  $ref: z2.string().optional(),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  type: z2.union([
+    z2.literal("string"),
+    z2.literal("number"),
+    z2.literal("integer"),
+    z2.literal("boolean"),
+    z2.literal("object"),
+    z2.literal("array"),
+    z2.literal("null")
+  ]).optional(),
+  enum: z2.array(z2.union([z2.string(), z2.number(), z2.boolean(), z2.null()])).optional(),
+  const: z2.union([z2.string(), z2.number(), z2.boolean(), z2.null()]).optional(),
+  multipleOf: z2.number().positive().optional(),
+  maximum: z2.number().optional(),
+  exclusiveMaximum: z2.number().optional(),
+  minimum: z2.number().optional(),
+  exclusiveMinimum: z2.number().optional(),
+  maxLength: z2.number().int().nonnegative().optional(),
+  minLength: z2.number().int().nonnegative().optional(),
+  pattern: z2.string().optional(),
+  additionalItems: z2.boolean().optional(),
+  items: z2.union([z2.lazy(() => jsonSchema7Schema), z2.array(jsonSchema7Schema)]).optional(),
+  maxItems: z2.number().int().nonnegative().optional(),
+  minItems: z2.number().int().nonnegative().optional(),
+  uniqueItems: z2.boolean().optional(),
+  contains: z2.lazy(() => jsonSchema7Schema).optional(),
+  maxProperties: z2.number().int().nonnegative().optional(),
+  minProperties: z2.number().int().nonnegative().optional(),
+  required: z2.array(z2.string()).optional(),
+  properties: z2.record(jsonSchema7Schema).optional(),
+  patternProperties: z2.record(jsonSchema7Schema).optional(),
+  additionalProperties: z2.union([z2.boolean(), z2.lazy(() => jsonSchema7Schema)]).optional(),
+  dependencies: z2.record(z2.union([z2.array(z2.string()), jsonSchema7Schema])).optional(),
+  propertyNames: z2.lazy(() => jsonSchema7Schema).optional(),
+  if: z2.lazy(() => jsonSchema7Schema).optional(),
+  then: z2.lazy(() => jsonSchema7Schema).optional(),
+  else: z2.lazy(() => jsonSchema7Schema).optional(),
+  allOf: z2.array(jsonSchema7Schema).optional(),
+  anyOf: z2.array(jsonSchema7Schema).optional(),
+  oneOf: z2.array(jsonSchema7Schema).optional(),
+  not: z2.lazy(() => jsonSchema7Schema).optional(),
+  definitions: z2.record(jsonSchema7Schema).optional(),
+  format: z2.string().optional(),
+  contentMediaType: z2.string().optional(),
+  contentEncoding: z2.string().optional()
+}));
+var jsonSchema7ObjectSchema = z2.object({
+  type: z2.literal("object"),
+  properties: z2.record(jsonSchema7Schema),
+  required: z2.array(z2.string()).optional(),
+  description: z2.string().optional(),
+  maxProperties: z2.number().int().nonnegative().optional(),
+  minProperties: z2.number().int().nonnegative().optional(),
+  additionalProperties: z2.boolean().optional()
+});
+
+// ../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([
+  z3.object({
+    default: z3.literal(false).default(false),
+    name: z3.string().min(1)
+  }),
+  z3.object({
+    default: z3.literal(true).default(true)
+  })
+])).and(z3.union([
+  z3.object({
+    exit: z3.literal(false).default(false),
+    target: z3.string().min(1)
+  }),
+  z3.object({ exit: z3.literal(true) })
+]));
+var defaultOutputSchema = z3.union([
+  z3.string().min(1),
+  z3.object({ default: z3.literal(true).default(true), exit: z3.literal(true) }),
+  z3.object({
+    default: z3.literal(true).default(true),
+    exit: z3.literal(false).default(false),
+    target: z3.string().min(1)
+  })
+]).transform((output) => {
+  if (typeof output === "string") {
+    return {
+      default: true,
+      exit: false,
+      target: output
+    };
+  }
+  return output;
+});
+var outputSchema = z3.union([z3.string().min(1), outputDefinitionSchema]).transform((output) => {
+  if (typeof output === "string") {
+    return {
+      default: true,
+      exit: false,
+      target: output
+    };
+  }
+  return output;
+});
+var defaultOutputsSchema = z3.array(defaultOutputSchema).default([]).superRefine(validateOutputs);
+var outputsSchema = z3.array(outputSchema).default([]).superRefine(validateOutputs);
+var idSchema = z3.string().uuid().default(() => crypto.randomUUID());
+var metaSchema = z3.record(z3.any()).optional();
+var entryNodeSchema = z3.object({
+  type: z3.literal("entry"),
+  id: z3.literal("__entry__").default("__entry__"),
+  output: defaultOutputsSchema,
+  inputSchema: jsonSchema7Schema.nullable().optional(),
+  metaSchema: jsonSchema7Schema.nullable().optional(),
+  meta: metaSchema
+});
+var serviceNodeSchema = z3.object({
+  type: z3.literal("service"),
+  output: outputsSchema,
+  inputSchema: jsonSchema7ObjectSchema.nullable().optional(),
+  id: idSchema,
+  name: z3.string(),
+  version: z3.string().default("*"),
+  configuration: z3.any().optional(),
+  alias: z3.string().optional(),
+  ttl: z3.number().int().min(1).optional(),
+  retry: z3.number().int().min(1).optional(),
+  retryDelay: z3.number().int().min(100).optional(),
+  meta: metaSchema
+});
+var catchNodeSchema = z3.object({
+  type: z3.literal("catch"),
+  output: outputsSchema,
+  id: idSchema,
+  subject: z3.string(),
+  meta: metaSchema
+});
+var logicNodeSchema = z3.object({
+  type: z3.literal("logic"),
+  alias: z3.string().optional(),
+  inputSchema: jsonSchema7ObjectSchema.nullable().optional(),
+  output: outputsSchema,
+  id: idSchema,
+  script: z3.string(),
+  concurrency: z3.boolean().default(true),
+  language: z3.enum(["javascript", "python", "typescript"]).default("javascript"),
+  maxExecutionTime: z3.number().int().min(0).default(200),
+  meta: metaSchema
+});
+var orNodeSchema = z3.object({
+  id: idSchema,
+  type: z3.literal("or"),
+  alias: z3.string().optional(),
+  output: outputsSchema,
+  meta: metaSchema
+});
+var nodeSchema = z3.discriminatedUnion("type", [
+  entryNodeSchema,
+  serviceNodeSchema,
+  catchNodeSchema,
+  logicNodeSchema,
+  orNodeSchema
+]);
+
+// ../helpers/src/protocol/nodes.ts
+class NodesError extends ZodError {
+  constructor(message, params, path = []) {
+    super([
+      {
+        code: z4.ZodIssueCode.custom,
+        message,
+        path,
+        params
+      }
+    ]);
+  }
+}
+var nodesSchema = z4.array(nodeSchema).transform((nodes) => {
+  const aliases = new Map;
+  const names = new Map;
+  let entryNode = null;
+  let firstNodeId = null;
+  for (const node2 of nodes) {
+    if (node2.type === "entry") {
+      entryNode = node2;
+    }
+    if ((node2.type === "service" || node2.type === "logic") && !firstNodeId) {
+      firstNodeId = node2.id;
+    }
+    if ("alias" in node2 && node2.alias) {
+      if (!aliases.has(node2.alias)) {
+        aliases.set(node2.alias, []);
+      }
+      aliases.get(node2.alias).push(node2.id);
+    }
+    if ("name" in node2 && node2.name) {
+      if (!names.has(node2.name)) {
+        names.set(node2.name, []);
+      }
+      names.get(node2.name).push(node2.id);
+    }
+  }
+  if (!entryNode && firstNodeId) {
+    nodes.unshift({
+      type: "entry",
+      id: "__entry__",
+      output: [{ default: true, exit: false, target: firstNodeId }]
+    });
+  }
+  const resolveOutput = (identifier) => {
+    if (aliases.get(identifier)?.length === 1) {
+      return aliases.get(identifier)[0];
+    }
+    if (names.get(identifier)?.length === 1) {
+      return names.get(identifier)[0];
+    }
+    return identifier;
+  };
+  return nodes.map((node2) => {
+    node2.output = node2.output.map((output) => ("target" in output) ? {
+      ...output,
+      target: resolveOutput(output.target)
+    } : output);
+    if ("subject" in node2) {
+      node2.subject = resolveOutput(node2.subject);
+    }
+    return node2;
+  });
+}).transform((nodes) => {
+  const { getInputs, getNode } = createNodeMaps(nodes);
+  const nodeAliases = new Set;
+  const nodeIds = new Set;
+  const catchSubjects = new Map;
+  const identify = (nodeId) => identifyNode(nodeId, getNode);
+  for (const node2 of nodes) {
+    if (nodeIds.has(node2.id)) {
+      throw new NodesError("id is not unique", {
+        id: node2.id
+      });
+    }
+    nodeIds.add(node2.id);
+    if ("alias" in node2 && node2.alias) {
+      if (nodeAliases.has(node2.alias)) {
+        throw new NodesError("alias is not unique", {
+          alias: node2.alias
+        });
+      }
+      nodeAliases.add(node2.alias);
+    }
+    if (node2.type === "catch") {
+      if (catchSubjects.has(node2.subject)) {
+        throw new NodesError("only one catch node per service allowed", {
+          id: node2.subject
+        });
+      }
+      catchSubjects.set(node2.subject, node2);
+    }
+  }
+  if (!getNode("__entry__")) {
+    throw new NodesError("missing entry node");
+  }
+  if (getInputs("__exit__").length === 0) {
+    throw new NodesError("no path leads to exit");
+  }
+  for (const catchNode of nodes.filter((node2) => node2.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);
+      if (!inputs || inputs.length < 2) {
+        throw new NodesError("or nodes need at least 2 inputs");
+      }
+    }
+    for (const targetNodeId of getNodeOutputs(node2)) {
+      if (targetNodeId !== "__exit__" && !getNode(targetNodeId)) {
+        throw new NodesError("missing node", {
+          id: targetNodeId
+        });
+      }
+    }
+  }
+  const possiblePaths = getPossiblePaths({
+    getInputs,
+    getNode,
+    onMissingInputs: (_node, path) => {
+      throw new NodesError("no path from entry to node", {
+        path: path.map(identify)
+      });
+    }
+  });
+  if (possiblePaths.every((possiblePath) => !possiblePath.includes("__entry__"))) {
+    throw new NodesError("no path from entry to exit");
+  }
+  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)) {
+        throw new NodesError("Unresolvable, inputs needs both catch and subject", {
+          path: possiblePath.map(identify)
+        });
+      }
+    }
+  }
+  return nodes;
+});
+
+// ../helpers/src/protocol/command.ts
+var abortSchema = z5.object({
+  type: z5.literal("ABORT"),
+  reason: z5.string().optional()
+});
+var nodeOptionsSchema = z5.object({
+  maxExecutions: z5.number().int().min(0).optional().default(10)
+});
+var createNodesSchema = z5.object({
+  type: z5.literal("CREATE_NODES"),
+  nodes: nodesSchema,
+  input: z5.any(),
+  meta: z5.any(),
+  options: nodeOptionsSchema
+});
+var commandSchema = z5.union([abortSchema, createNodesSchema]);
+// ../helpers/src/protocol/update.ts
+import {z as z6} from "zod";
+var baseUpdateSchema = z6.object({
+  timestamp: z6.number().int().transform((int) => new Date(int))
+});
+var baseNodeUpdateSchema = baseUpdateSchema.extend({
+  nodeId: z6.string().uuid()
+});
+var nodeStartUpdateSchema = baseNodeUpdateSchema.extend({
+  type: z6.literal("NODE_START"),
+  context: contextSchema
+});
+var nodeErrorUpdateSchema = baseNodeUpdateSchema.extend({
+  type: z6.literal("NODE_ERROR"),
+  error: z6.string(),
+  context: contextSchema
+});
+var nodeUpdateSchema = baseNodeUpdateSchema.extend({
+  type: z6.literal("NODE_UPDATE"),
+  output: z6.string(),
+  data: z6.unknown(),
+  context: contextSchema
+});
+var nodeFinishedUpdateSchema = baseNodeUpdateSchema.extend({
+  type: z6.literal("NODE_FINISHED"),
+  context: contextSchema
+});
+var nodeDebugUpdateSchema = baseNodeUpdateSchema.extend({
+  type: z6.literal("NODE_DEBUG"),
+  severity: z6.enum(["log", "info", "warn", "error"]),
+  data: z6.unknown(),
+  context: contextSchema
+});
+var nodeDeferUpdateSchema = baseNodeUpdateSchema.extend({
+  type: z6.literal("NODE_DEFER"),
+  data: z6.unknown(),
+  context: contextSchema
+});
+var taskStartUpdateSchema = baseUpdateSchema.extend({
+  type: z6.literal("TASK_START"),
+  nodes: nodesSchema,
+  context: contextSchema
+});
+var taskErrorUpdateSchema = baseUpdateSchema.extend({
+  type: z6.literal("TASK_ERROR"),
+  reason: z6.string().optional(),
+  context: contextSchema
+});
+var taskFinishedUpdateSchema = baseUpdateSchema.extend({
+  type: z6.literal("TASK_FINISHED"),
+  context: contextSchema
+});
+var updateSchema = z6.discriminatedUnion("type", [
+  nodeStartUpdateSchema,
+  nodeErrorUpdateSchema,
+  nodeUpdateSchema,
+  nodeFinishedUpdateSchema,
+  nodeDebugUpdateSchema,
+  nodeDeferUpdateSchema,
+  taskStartUpdateSchema,
+  taskErrorUpdateSchema,
+  taskFinishedUpdateSchema
+]);
+// src/connections/createAmqpConnection.ts
+import {connect} from "amqp-connection-manager";
+import semver from "semver";
+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) {
+    super();
+    this.delay = delay;
+  }
+}
+
+class AbortError extends Error {
+}
+var OUTPUT_VALUE = Symbol("output_value");
+function createExtendedContextHelper(options) {
+  const contextHelper = createContextHelper(options.context, options.nodes);
+  const internalContext = getInternalContext(contextHelper);
+  return Object.assign(contextHelper, {
+    taskId: options.taskId,
+    toOutput(name, value) {
+      return {
+        [OUTPUT_VALUE]: name,
+        value
+      };
+    },
+    defer: options.onDefer,
+    getConfiguration() {
+      const result = internalContext.results.get(options.serviceId);
+      if (result?.node.type === "service") {
+        return result.node.configuration ?? null;
+      }
+      return null;
+    },
+    getNode() {
+      return internalContext.results.get(options.serviceId).node;
+    },
+    state: createObjectProxy(options.state, options.onStateChange),
+    debug: {
+      log(...data) {
+        options.onLog("log", data);
+      },
+      info(...data) {
+        options.onLog("info", data);
+      },
+      warn(...data) {
+        options.onLog("warn", data);
+      },
+      error(...data) {
+        options.onLog("error", data);
+      }
+    },
+    retry(delay) {
+      throw new RetryError(delay);
+    },
+    abort(reason) {
+      throw new AbortError(reason);
+    }
+  });
+}
+
+// src/connections/createAmqpConnection.ts
+function isMessageHandlerGenerator(handler) {
+  return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
+}
+var messageKeySchema = z7.string().transform((str) => deobfuscate(str)).pipe(z7.array(z7.string().uuid()).length(3)).transform((arr) => ({
+  taskId: arr[0],
+  serviceId: arr[1],
+  messageId: arr[2]
+}));
+var headerSchema = z7.object({
+  properties: z7.object({
+    correlationId: z7.string().uuid(),
+    headers: z7.object({
+      version: z7.string(),
+      taskId: z7.string().uuid(),
+      serviceId: z7.string().uuid()
+    })
+  })
+}).transform((msg) => ({
+  version: msg.properties.headers.version,
+  messageId: msg.properties.correlationId,
+  taskId: msg.properties.headers.taskId,
+  serviceId: msg.properties.headers.serviceId
+}));
+var payloadSchema = z7.object({ content: z7.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z7.object({
+  context: contextSchema,
+  meta: z7.object({
+    nodes: nodesSchema,
+    state: z7.record(z7.any())
+  })
+}));
+var activeMessages = new Set;
+function createConnection({
+  url,
+  version,
+  prefetch = 1,
+  silent = false,
+  connectionTimeout
+}, messageHandler) {
+  const queue = url.username;
+  const exchange = url.username;
+  const connection = connect(url.toString());
+  const connectedPromise = new Promise((resolve, reject) => {
+    const unsubscribe = () => {
+      clearTimeout(timeout);
+      connection.removeListener("connect", handleConnect);
+      connection.removeListener("connectFailed", handleConnectFailed);
+    };
+    const timeout = setTimeout(() => {
+      handleConnectFailed({ err: "Connection timeout" });
+    }, connectionTimeout);
+    const handleConnect = () => {
+      unsubscribe();
+      resolve();
+    };
+    const handleConnectFailed = ({ err }) => {
+      unsubscribe();
+      reject(new Error(err));
+    };
+    connection.addListener("connect", handleConnect);
+    connection.addListener("connectFailed", handleConnectFailed);
+  });
+  const channel = connection.createChannel({
+    async setup(channel2) {
+      await channel2.checkExchange(exchange);
+      await channel2.checkExchange(`${exchange}-retry`);
+      await channel2.checkQueue(queue);
+      await channel2.prefetch(prefetch);
+    }
+  });
+  const publish = ({
+    data,
+    outputName,
+    messageId,
+    ...headers
+  }) => {
+    channel.publish(exchange, "", Buffer.from(JSON.stringify(data ?? null)), {
+      correlationId: messageId,
+      contentType: "application/json",
+      headers: {
+        outputName: outputName ?? null,
+        ...headers
+      }
+    });
+  };
+  channel.consume(queue, async (message) => {
+    if (message.properties.headers?.abort || message.properties.headers?.exception) {
+      channel.nack(message, false, false);
+      return;
+    }
+    let removeActiveMessage = () => {
+    };
+    try {
+      let deferred = false;
+      let deferredReason = null;
+      const {
+        messageId,
+        serviceId,
+        taskId,
+        version: expectedVersion
+      } = 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 = () => {
+        if (!acked) {
+          acked = true;
+          channel.ack(message);
+        }
+      };
+      let immediateUpdateState;
+      const extendedContext = createExtendedContextHelper({
+        serviceId,
+        context: payload.context,
+        nodes: payload.meta.nodes,
+        taskId,
+        state: payload.meta.state,
+        onStateChange(newState) {
+          clearImmediate(immediateUpdateState);
+          immediateUpdateState = setImmediate(() => {
+            publish({
+              messageId,
+              taskId,
+              serviceId,
+              data: clone(newState),
+              state: true
+            });
+          });
+        },
+        onLog(debugMethod, data) {
+          publish({
+            messageId,
+            taskId,
+            serviceId,
+            data,
+            debugMethod,
+            debug: true
+          });
+        },
+        onDefer(reason) {
+          deferred = true;
+          deferredReason = reason || null;
+          ack();
+          return obfuscate(taskId, serviceId, messageId);
+        }
+      });
+      if (isMessageHandlerGenerator(messageHandler)) {
+        const generator = messageHandler(extendedContext);
+        while (true) {
+          const { value: result, done } = await generator.next();
+          ack();
+          if (deferred) {
+            deferred = false;
+            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) {
+            break;
+          }
+        }
+      } else {
+        const result = await messageHandler(extendedContext);
+        ack();
+        const { value, outputName } = unwrapResult(result);
+        if (deferred && value) {
+          console.warn("returning a value in a deferred message resets the deferred status");
+          deferred = false;
+        }
+        if (!deferred || value) {
+          publish({
+            messageId,
+            taskId,
+            serviceId,
+            data: value,
+            outputName
+          });
+        }
+      }
+      publish({
+        messageId,
+        taskId,
+        serviceId,
+        data: deferredReason,
+        deferred,
+        done: !deferred
+      });
+    } catch (error) {
+      if (error instanceof RetryError) {
+        const properties = {
+          ...message.properties,
+          expiration: error.delay || 1000
+        };
+        channel.publish(`${exchange}-retry`, "retry", message.content, properties);
+        channel.ack(message);
+        return;
+      }
+      if (error instanceof AbortError && error.message.length > 0) {
+        channel.publish(`${exchange}-retry`, "requeue", error.message, {
+          ...message.properties,
+          expiration: 0,
+          priority: 0,
+          contentType: "text/plain",
+          headers: {
+            ...message.properties.headers,
+            abort: true
+          }
+        });
+        channel.ack(message);
+        return;
+      }
+      if (error instanceof Error) {
+        if (!silent) {
+          console.error(`Encountered an error inside service handler:`);
+          console.error(error);
+        }
+        channel.publish(`${exchange}-retry`, "requeue", message.content, {
+          ...message.properties,
+          expiration: 0,
+          priority: 0,
+          headers: {
+            ...message.properties.headers,
+            exception: true,
+            "error-message": error.message || "error in service handler"
+          }
+        });
+        channel.ack(message);
+        return;
+      }
+      channel.nack(message, false, false);
+    } finally {
+      removeActiveMessage();
+    }
+  });
+  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
+      });
+    },
+    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
+      });
+    },
+    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({
+        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;
+}
+
+// src/index.ts
+var versionSchema = z8.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/, "not a valid version");
+var connectionOptionsSchema = z8.object({
+  url: z8.union([
+    z8.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
+    z8.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+  ]),
+  version: versionSchema,
+  silent: z8.boolean().optional(),
+  prefetch: z8.number().int().optional(),
+  connectionTimeout: z8.number().positive().default(3000)
+});
+function createService(optionsOrVersion, optionalMessageHandler) {
+  let options;
+  let messageHandler;
+  if (typeof optionsOrVersion === "string") {
+    options = {
+      version: optionsOrVersion
+    };
+    messageHandler = optionalMessageHandler;
+  } else {
+    options = optionsOrVersion;
+    messageHandler = 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");
+  }
+  const parts = deobfuscate(key);
+  if (parts.length < 2 || parts[0] !== "service") {
+    throw new Error("Invalid service key");
+  }
+  const connectionOptions = {
+    ...options,
+    url: parts[1]
+  };
+  return createConnection(connectionOptionsSchema.parse(connectionOptions), messageHandler);
+}
+export {
+  createService as default
+};
+
+//# debugId=C7AD515DE676451264756E2164756E21
+//# sourceMappingURL=index.js.map