@relaybus/core 0.4.0 → 0.4.1

package/README.md

@@ -394,6 +394,7 @@ never renamed or reused once released, so branch on them in alerts and retry rul
 | `RELAYBUS_RABBITMQ_UNROUTABLE_MESSAGE`     | `UnroutableMessageError`        | `@relaybus/rabbitmq` |
 | `RELAYBUS_RABBITMQ_MALFORMED_MESSAGE`      | `MalformedMessageError`         | `@relaybus/rabbitmq` |
 | `RELAYBUS_RABBITMQ_UNSERIALIZABLE_PAYLOAD` | `UnserializablePayloadError`    | `@relaybus/rabbitmq` |
+| `RELAYBUS_TESTING_CODEC_CONTRACT`          | `CodecContractError`            | `@relaybus/testing`  |
 | `RELAYBUS_RABBITMQ_UNENCODABLE_EVENT`      | `RabbitMqUnencodableEventError` | `@relaybus/rabbitmq` |
 | `RELAYBUS_RABBITMQ_AMQP_LIMIT_EXCEEDED`    | `AmqpLimitExceededError`        | `@relaybus/rabbitmq` |
 

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",
@@ -116,8 +165,9 @@ function compile(mapping, transportIds) {
   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,
@@ -127,6 +177,8 @@ function compile(mapping, transportIds) {
     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);
@@ -160,6 +212,20 @@ function compileExtras(mapping, hasBody) {
     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"]);
@@ -269,6 +335,56 @@ 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+$/;
@@ -305,13 +421,8 @@ function readType(message, { plan, failures }) {
     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) {
@@ -321,7 +432,10 @@ 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) {
@@ -411,7 +525,7 @@ function writeMessage(envelope, { plan, failures }) {
   };
   const typeAt = typeLocation(envelope, { plan, failures });
   if (typeAt !== void 0) {
-    put(typeAt, envelope.type);
+    put(typeAt, wireTypeOf(envelope, { plan, failures }));
   }
   if (plan.id !== void 0) {
     put(plan.id, envelope.id);
@@ -422,12 +536,8 @@ function writeMessage(envelope, { plan, failures }) {
       put(location, value);
     }
   }
-  const body = writeBody(envelope, { plan, root });
-  if (plan.topLevelHeaders) {
-    spreadHeaders(envelope, { plan, failures, root: body });
-  }
   return {
-    body,
+    body: writeBody(envelope, { plan, failures, root }),
     headers: Object.fromEntries([
       ...eventHeaderEntries(envelope, { plan, failures }),
       ...headers,
@@ -464,11 +574,12 @@ function optionalValues(envelope, { plan, failures }) {
     ["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,
@@ -478,6 +589,10 @@ function writeBody(envelope, { plan, 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 }) {
@@ -490,6 +605,20 @@ function spreadHeaders(envelope, { plan, failures, root }) {
     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") {