@relaybus/core 0.3.1 → 0.4.1

package/dist/internal/index.cjs

@@ -90,6 +90,55 @@ function writeStructuredCloudEvent(envelope, { time, data }) {
   return `${JSON.stringify(attributes).slice(0, -1)},"data":${data}}`;
 }
 
+// src/internal/json-envelope-wire-types.ts
+function compileWireTypes(wireTypes, { fixed }) {
+  if (wireTypes === void 0) {
+    return { wireTypes: /* @__PURE__ */ new Map(), eventTypes: /* @__PURE__ */ new Map() };
+  }
+  if (!isJsonObject(wireTypes) || fixed) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      "jsonEnvelope wireTypes must be an object of event type to wire name, with a type at { body } or { header }"
+    );
+  }
+  const entries = Object.entries(wireTypes);
+  const eventTypes = /* @__PURE__ */ new Map();
+  for (const [type, wire] of entries) {
+    chunkJ76M7XTS_cjs.assertEventType(type);
+    if (typeof wire !== "string" || wire.length === 0 || eventTypes.has(wire)) {
+      throw new chunkJ76M7XTS_cjs.ConfigurationError(
+        `jsonEnvelope wireTypes needs a non-empty wire name for '${type}' that no other type uses`
+      );
+    }
+    eventTypes.set(wire, type);
+  }
+  return { wireTypes: new Map(entries), eventTypes };
+}
+function wireTypeOf(envelope, { plan, failures }) {
+  const wire = plan.wireTypes.get(envelope.type);
+  if (wire !== void 0) {
+    return wire;
+  }
+  const other = plan.eventTypes.get(envelope.type);
+  if (other !== void 0) {
+    throw failures.unencodable(
+      `Event ${envelope.id} has type '${envelope.type}', which wireTypes uses as the wire name of '${other}'`
+    );
+  }
+  return envelope.type;
+}
+function eventTypeOf(wire, { plan, failures }) {
+  const type = plan.eventTypes.get(wire);
+  if (type !== void 0) {
+    return type;
+  }
+  try {
+    chunkJ76M7XTS_cjs.assertEventType(wire);
+  } catch (error) {
+    throw failures.invalid(`The event type is not a valid event type: ${error.message}`);
+  }
+  return wire;
+}
+
 // src/internal/json-envelope-plan.ts
 var OPTIONAL_NAMES = [
   "key",
@@ -98,6 +147,7 @@ var OPTIONAL_NAMES = [
   "correlationId",
   "causationId"
 ];
+var TIME_FORMATS = ["rfc3339", "epoch-millis", "epoch-seconds"];
 var ARRAY_INDEX = /^(?:0|[1-9]\d*)$/;
 function compile(mapping, transportIds) {
   if (!isJsonObject(mapping)) {
@@ -110,16 +160,72 @@ function compile(mapping, transportIds) {
       optional[name] = toLocation(field, name);
     }
   }
+  const payload = compilePayload(mapping.payload);
+  const topLevelHeaders = mapping.headers === "top-level-fields";
+  if (topLevelHeaders && payload === void 0) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError("jsonEnvelope headers 'top-level-fields' needs a body payload");
+  }
+  const type = compileType(mapping.type);
   const plan = {
-    type: compileType(mapping.type),
+    type,
     id: compileId(mapping.id, transportIds),
+    idWhenMissing: isJsonObject(mapping.id) && "whenMissing" in mapping.id,
     optional,
-    payload: compilePayload(mapping.payload),
-    headers: compileHeaders(mapping.headers),
-    mappedHeaders: /* @__PURE__ */ new Set()
+    payload,
+    headers: topLevelHeaders ? void 0 : compileHeaders(mapping.headers),
+    topLevelHeaders,
+    topLevelNames: /* @__PURE__ */ new Set(),
+    mappedHeaders: /* @__PURE__ */ new Set(),
+    timeFormat: compileTimeFormat(mapping.occurredAt),
+    otherFields: compileOtherFields(mapping, payload !== void 0),
+    ...compileWireTypes(mapping.wireTypes, { fixed: "fixed" in type }),
+    ...compileExtras(mapping, payload !== void 0)
   };
   return assertDisjoint(plan);
 }
+function compileTimeFormat(field) {
+  const format = isJsonObject(field) ? field["format"] : void 0;
+  if (format === void 0) {
+    return "rfc3339";
+  }
+  if (!TIME_FORMATS.includes(format)) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      `jsonEnvelope occurredAt format must be one of ${TIME_FORMATS.map((name) => `'${name}'`).join(", ")}`
+    );
+  }
+  return format;
+}
+function compileExtras(mapping, hasBody) {
+  const extra = mapping.extra ?? {};
+  const bodyOrder = mapping.bodyOrder ?? [];
+  if (!hasBody && (extra.body !== void 0 || bodyOrder.length > 0)) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      "jsonEnvelope with a whole-body payload has no body for extra values or a body order"
+    );
+  }
+  return {
+    extraBody: Object.entries(extra.body ?? {}).map(([path, value]) => ({
+      path: toPath(path, "extra body value"),
+      value
+    })),
+    extraHeaders: Object.entries(extra.headers ?? {}),
+    bodyOrder
+  };
+}
+function compileOtherFields(mapping, hasBody) {
+  const otherFields = mapping.otherFields;
+  if (otherFields === void 0) {
+    return void 0;
+  }
+  if (!hasBody) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError("jsonEnvelope otherFields needs a body payload");
+  }
+  const field = isJsonObject(otherFields) ? otherFields["payloadField"] : void 0;
+  if (typeof field !== "string" || field.length === 0) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError("jsonEnvelope otherFields must be { payloadField: '<name>' }");
+  }
+  return field;
+}
 function compileType(type) {
   if (isJsonObject(type) && typeof type["fixed"] === "string") {
     chunkJ76M7XTS_cjs.assertEventType(type["fixed"]);
@@ -134,11 +240,15 @@ function compileId(id, transportIds) {
   if (typeof id === "string" && transportIds.includes(id)) {
     return void 0;
   }
+  const names = transportIds.map((name) => `'${name}'`).join(", ");
   if (!isJsonObject(id)) {
     throw new chunkJ76M7XTS_cjs.ConfigurationError(
-      `jsonEnvelope needs an id: { body }, { header } or one of ${transportIds.map((name) => `'${name}'`).join(", ")}`
+      `jsonEnvelope needs an id: { body }, { header } or one of ${names}`
     );
   }
+  if ("whenMissing" in id && !transportIds.includes(id["whenMissing"])) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(`jsonEnvelope id whenMissing must be one of ${names}`);
+  }
   return toLocation(id, "id");
 }
 function compilePayload(payload) {
@@ -187,17 +297,25 @@ function assertDisjoint(plan) {
   const locations = [plan.type, plan.id, ...Object.values(plan.optional)].filter(
     (location) => location !== void 0 && !("fixed" in location)
   );
-  const headers = locations.flatMap((location) => "header" in location ? [location.header] : []);
+  const headers = [
+    ...locations.flatMap((location) => "header" in location ? [location.header] : []),
+    ...plan.extraHeaders.map(([name]) => name)
+  ];
   const duplicate = headers.find((name, index) => headers.indexOf(name) !== index);
   if (duplicate !== void 0) {
     throw new chunkJ76M7XTS_cjs.ConfigurationError(`jsonEnvelope maps header '${duplicate}' twice`);
   }
   const paths = [
     ...locations.flatMap((location) => "path" in location ? [location.path] : []),
-    ...[plan.payload, plan.headers].filter((path) => path !== void 0)
+    ...[plan.payload, plan.headers].filter((path) => path !== void 0),
+    ...plan.extraBody.map(({ path }) => path)
   ];
   assertNoNestedPaths(paths);
-  return { ...plan, mappedHeaders: new Set(headers) };
+  return {
+    ...plan,
+    mappedHeaders: new Set(headers),
+    topLevelNames: new Set(paths.map((path) => path[0]))
+  };
 }
 function assertNoNestedPaths(paths) {
   paths.forEach((path, index) => {
@@ -217,8 +335,60 @@ function assertCompatiblePaths(path, other) {
   }
 }
 
+// src/internal/json-envelope-other-fields.ts
+function unusedFields(body, { plan }) {
+  return Object.entries(body).filter(
+    ([name, value]) => !plan.topLevelNames.has(name) && !(plan.topLevelHeaders && typeof value === "string")
+  );
+}
+function withOtherFields(payload, { body, context }) {
+  const field = context.plan.otherFields;
+  if (field === void 0) {
+    return payload;
+  }
+  const fields = unusedFields(body, context);
+  if (!isJsonObject(payload) && fields.length === 0) {
+    return payload;
+  }
+  if (!isJsonObject(payload) || Object.hasOwn(payload, field)) {
+    throw context.failures.invalid(
+      `otherFields keeps the unused top-level fields under the payload field '${field}', but the payload is not an object without that field`
+    );
+  }
+  return Object.fromEntries([...Object.entries(payload), [field, Object.fromEntries(fields)]]);
+}
+function splitOtherFields(envelope, context) {
+  const field = context.plan.otherFields;
+  const { payload } = envelope;
+  if (field === void 0 || !isJsonObject(payload) || !Object.hasOwn(payload, field)) {
+    return { payload, fields: [] };
+  }
+  const others = payload[field];
+  if (!isJsonObject(others)) {
+    throw context.failures.unencodable(
+      `Event ${envelope.id} has a payload field '${field}' that is not an object of top-level fields`
+    );
+  }
+  const fields = Object.entries(others);
+  const refused = fields.find((entry) => isRefused(entry, context));
+  if (refused !== void 0) {
+    throw context.failures.unencodable(
+      `Event ${envelope.id} keeps a top-level field '${refused[0]}' under '${field}' that the mapping reads as another value`
+    );
+  }
+  return {
+    payload: Object.fromEntries(Object.entries(payload).filter(([name]) => name !== field)),
+    fields
+  };
+}
+function isRefused([name, value], { plan }) {
+  return plan.topLevelNames.has(name) || plan.topLevelHeaders && typeof value === "string";
+}
+
 // src/internal/json-envelope-read.ts
 var RFC3339_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/i;
+var EPOCH_PATTERN = /^\d+$/;
+var MILLISECONDS_PER_SECOND = 1e3;
 function readMessage(message, context) {
   const { plan, failures } = context;
   if (plan.payload !== void 0 && !isJsonObject(message.body)) {
@@ -226,7 +396,7 @@ function readMessage(message, context) {
   }
   const read = (location) => location === void 0 ? void 0 : readText(message, { location, failures });
   const fields = {
-    id: plan.id === void 0 ? void 0 : requireText(read(plan.id), { location: plan.id, failures }),
+    id: readId(read(plan.id), context),
     type: readType(message, context),
     payload: readPayload(message.body, context),
     key: read(plan.optional.key),
@@ -234,24 +404,25 @@ function readMessage(message, context) {
     headers: readEventHeaders(message, plan),
     correlationId: read(plan.optional.correlationId) ?? null,
     causationId: read(plan.optional.causationId) ?? null,
-    occurredAt: readTime(read(plan.optional.occurredAt), failures)
+    occurredAt: readTime(read(plan.optional.occurredAt), context)
   };
   return Object.fromEntries(
     Object.entries(fields).filter((entry) => entry[1] !== void 0)
   );
 }
+function readId(id, { plan, failures }) {
+  if (plan.id === void 0 || plan.idWhenMissing) {
+    return id;
+  }
+  return requireText(id, { location: plan.id, failures });
+}
 function readType(message, { plan, failures }) {
   if ("fixed" in plan.type) {
     return plan.type.fixed;
   }
   const location = plan.type;
-  const type = requireText(readText(message, { location, failures }), { location, failures });
-  try {
-    chunkJ76M7XTS_cjs.assertEventType(type);
-  } catch (error) {
-    throw failures.invalid(`The event type is not a valid event type: ${error.message}`);
-  }
-  return type;
+  const wire = requireText(readText(message, { location, failures }), { location, failures });
+  return eventTypeOf(wire, { plan, failures });
 }
 function readPayload(body, { plan, failures }) {
   if (plan.payload === void 0) {
@@ -261,25 +432,45 @@ function readPayload(body, { plan, failures }) {
   if (payload === void 0) {
     throw failures.invalid(`The message has no payload at '${plan.payload.join(".")}'`);
   }
-  return payload;
+  return withOtherFields(payload, {
+    body,
+    context: { plan, failures }
+  });
 }
 function readEventHeaders(message, plan) {
+  if (plan.topLevelHeaders) {
+    return textEntries(
+      Object.entries(message.body).filter(
+        ([name]) => !plan.topLevelNames.has(name)
+      )
+    );
+  }
   if (plan.headers === void 0) {
     return Object.fromEntries(
       Object.entries(message.headers).filter(([name]) => !plan.mappedHeaders.has(name))
     );
   }
   const headers = valueAt(message.body, plan.headers);
-  return isJsonObject(headers) ? Object.fromEntries(
-    Object.entries(headers).filter(
-      (entry) => typeof entry[1] === "string"
-    )
-  ) : {};
+  return isJsonObject(headers) ? textEntries(Object.entries(headers)) : {};
 }
-function readTime(text, failures) {
+function textEntries(entries) {
+  return Object.fromEntries(
+    entries.filter((entry) => typeof entry[1] === "string")
+  );
+}
+function readTime(text, { plan, failures }) {
   if (text === void 0) {
     return void 0;
   }
+  if (plan.timeFormat !== "rfc3339") {
+    const time2 = new Date(
+      Number(text) * (plan.timeFormat === "epoch-seconds" ? MILLISECONDS_PER_SECOND : 1)
+    );
+    if (!EPOCH_PATTERN.test(text) || Number.isNaN(time2.getTime())) {
+      throw failures.invalid(`The event time is not a whole ${plan.timeFormat} number: '${text}'`);
+    }
+    return time2;
+  }
   const time = new Date(text);
   if (!RFC3339_PATTERN.test(text) || Number.isNaN(time.getTime())) {
     throw failures.invalid(`The event time is not an RFC 3339 timestamp: '${text}'`);
@@ -321,63 +512,135 @@ function valueAt(body, path) {
 
 // src/internal/json-envelope-write.ts
 var MAXIMUM_RFC3339_YEAR = 9999;
+var MILLISECONDS_PER_SECOND2 = 1e3;
 function writeMessage(envelope, { plan, failures }) {
   const root = {};
   const headers = [];
   const put = (location, value) => {
     if ("header" in location) {
-      headers.push([location.header, value]);
+      headers.push([location.header, String(value)]);
     } else {
       setAt(root, { path: location.path, value });
     }
   };
-  if ("fixed" in plan.type) {
-    if (envelope.type !== plan.type.fixed) {
-      throw failures.unencodable(
-        `Event ${envelope.id} has type '${envelope.type}', but this route carries only '${plan.type.fixed}'`
-      );
-    }
-  } else {
-    put(plan.type, envelope.type);
+  const typeAt = typeLocation(envelope, { plan, failures });
+  if (typeAt !== void 0) {
+    put(typeAt, wireTypeOf(envelope, { plan, failures }));
   }
   if (plan.id !== void 0) {
     put(plan.id, envelope.id);
   }
-  for (const [name, value] of optionalValues(envelope, failures)) {
+  for (const [name, value] of optionalValues(envelope, { plan, failures })) {
     const location = plan.optional[name];
     if (location !== void 0 && value !== null) {
       put(location, value);
     }
   }
   return {
-    body: writeBody(envelope, { plan, root }),
-    headers: Object.fromEntries([...eventHeaderEntries(envelope, { plan, failures }), ...headers])
+    body: writeBody(envelope, { plan, failures, root }),
+    headers: Object.fromEntries([
+      ...eventHeaderEntries(envelope, { plan, failures }),
+      ...headers,
+      ...extraHeaderEntries(envelope, plan)
+    ])
   };
 }
-function optionalValues(envelope, failures) {
+function typeLocation(envelope, { plan, failures }) {
+  if (!("fixed" in plan.type)) {
+    return plan.type;
+  }
+  if (envelope.type !== plan.type.fixed) {
+    throw failures.unencodable(
+      `Event ${envelope.id} has type '${envelope.type}', but this route carries only '${plan.type.fixed}'`
+    );
+  }
+  return void 0;
+}
+function extraHeaderEntries(envelope, plan) {
+  return plan.extraHeaders.map(([name, value]) => [
+    name,
+    typeof value === "function" ? value(envelope) : value
+  ]);
+}
+function optionalValues(envelope, { plan, failures }) {
   return [
     ["key", envelope.key],
     ["source", envelope.source],
-    ["occurredAt", formatTime(envelope, failures)],
+    [
+      "occurredAt",
+      timeValue(formatTime(envelope, failures), { envelope, format: plan.timeFormat })
+    ],
     ["correlationId", envelope.correlationId],
     ["causationId", envelope.causationId]
   ];
 }
-function writeBody(envelope, { plan, root }) {
+function writeBody(envelope, { plan, failures, root }) {
+  const { payload, fields } = splitOtherFields(envelope, { plan, failures });
   if (plan.payload === void 0) {
-    return envelope.payload;
+    return payload;
   }
-  setAt(root, { path: plan.payload, value: envelope.payload });
+  setAt(root, { path: plan.payload, value: payload });
   if (plan.headers !== void 0) {
     setAt(root, {
       path: plan.headers,
       value: Object.fromEntries(Object.entries(envelope.headers))
     });
   }
-  return root;
+  for (const { path, value } of plan.extraBody) {
+    setAt(root, { path, value: typeof value === "function" ? value(envelope) : value });
+  }
+  if (plan.topLevelHeaders) {
+    spreadHeaders(envelope, { plan, failures, root });
+  }
+  spreadOtherFields(envelope, { failures, fields, root });
+  return ordered(root, plan.bodyOrder);
+}
+function spreadHeaders(envelope, { plan, failures, root }) {
+  for (const [name, value] of Object.entries(envelope.headers)) {
+    if (plan.topLevelNames.has(name)) {
+      throw failures.unencodable(
+        `Event ${envelope.id} has a header '${name}', which the mapping uses for another body field`
+      );
+    }
+    setAt(root, { path: [name], value });
+  }
+}
+function spreadOtherFields(envelope, {
+  failures,
+  fields,
+  root
+}) {
+  for (const [name, value] of fields) {
+    if (Object.hasOwn(root, name)) {
+      throw failures.unencodable(
+        `Event ${envelope.id} keeps a top-level field '${name}' that an event header also writes`
+      );
+    }
+    setAt(root, { path: [name], value });
+  }
+}
+function timeValue(text, { envelope, format }) {
+  const milliseconds = envelope.occurredAt.getTime();
+  if (format === "epoch-millis") {
+    return milliseconds;
+  }
+  return format === "epoch-seconds" ? Math.floor(milliseconds / MILLISECONDS_PER_SECOND2) : text;
+}
+function ordered(root, order) {
+  if (order.length === 0) {
+    return root;
+  }
+  const result = {};
+  const names = [...order.filter((name) => Object.hasOwn(root, name)), ...Object.keys(root)];
+  for (const name of names) {
+    if (!Object.hasOwn(result, name)) {
+      defineValue(result, { name, value: root[name] });
+    }
+  }
+  return result;
 }
 function eventHeaderEntries(envelope, { plan, failures }) {
-  if (plan.headers !== void 0) {
+  if (plan.headers !== void 0 || plan.topLevelHeaders) {
     return [];
   }
   const entries = Object.entries(envelope.headers);