blume 2.1.0 → 2.1.2

package/src/components/openapi/RequestBody.astro

@@ -1,6 +1,7 @@
 ---
 import Description from "./Description.astro";
 import type { SchemaLike } from "./helpers.ts";
+import type { SchemaDirection } from "./schema-tree.ts";
 import SchemaTable from "./SchemaTable.astro";
 
 interface MediaTypeLike {
@@ -19,9 +20,20 @@ interface Props {
   expandAll?: boolean;
   /** The heading's level: 2 on an operation, deeper inside a callback. */
   level?: number;
+  /**
+   * `request` (the default) leaves out `readOnly` fields; a webhook or
+   * callback, which the API sends, reads like a response instead.
+   */
+  direction?: SchemaDirection;
 }
 
-const { requestBody, schemas, expandAll = false, level = 2 } = Astro.props;
+const {
+  requestBody,
+  schemas,
+  expandAll = false,
+  level = 2,
+  direction = "request",
+} = Astro.props;
 
 const entries = Object.entries(requestBody.content ?? {});
 const chosen = entries.find(([type]) => type.includes("json")) ?? entries[0];
@@ -53,6 +65,11 @@ const schema = chosen?.[1]?.schema ?? {};
     )
   }
   <div class="mt-3">
-    <SchemaTable expandAll={expandAll} schema={schema} schemas={schemas} />
+    <SchemaTable
+      direction={direction}
+      expandAll={expandAll}
+      schema={schema}
+      schemas={schemas}
+    />
   </div>
 </section>

package/src/components/openapi/Responses.astro

@@ -64,6 +64,7 @@ const items = Object.entries(responses);
               {schema && (
                 <div class="mt-3">
                   <SchemaTable
+                    direction="response"
                     expandAll={expandAll}
                     schema={schema}
                     schemas={schemas}

package/src/components/openapi/SchemaTable.astro

@@ -1,6 +1,10 @@
 ---
 import type { SchemaLike } from "./helpers.ts";
-import { type SchemaNode, schemaTree } from "./schema-tree.ts";
+import {
+  type SchemaDirection,
+  type SchemaNode,
+  schemaTree,
+} from "./schema-tree.ts";
 import SchemaProperty from "./SchemaProperty.astro";
 
 interface Props {
@@ -10,13 +14,21 @@ interface Props {
   node?: SchemaNode;
   schemas: Record<string, SchemaLike>;
   expandAll?: boolean;
+  /** Which way the data travels, which decides the fields left out. */
+  direction?: SchemaDirection;
 }
 
-const { schema = {}, node: planned, schemas, expandAll = false } = Astro.props;
+const {
+  schema = {},
+  node: planned,
+  schemas,
+  expandAll = false,
+  direction,
+} = Astro.props;
 
 // The whole tree is planned once, at the top-level table, so that which named
 // schemas expand is decided for the tree as a whole (see `schema-tree.ts`).
-const node = planned ?? schemaTree(schema, schemas);
+const node = planned ?? schemaTree(schema, schemas, direction);
 ---
 
 {

package/src/components/openapi/async-snippets.ts

@@ -25,7 +25,12 @@ export interface MessageSample {
   address: string;
   /** Example payload value (undefined when none could be derived). */
   payload?: unknown;
-  /** First server the channel is available on, if any. */
+  /** Example Kafka message key, when the message's binding declares one. */
+  key?: string;
+  /**
+   * First server the channel is available on, if any, its `security` entries
+   * resolved to scheme objects.
+   */
   server?: AsyncApiServerObject;
 }
 
@@ -98,12 +103,63 @@ const webSocketSnippet = (sample: MessageSample): string => {
   ].join("\n");
 };
 
+/** librdkafka's `sasl.mechanisms` value for each AsyncAPI SASL scheme type. */
+const SASL_MECHANISMS = new Map([
+  ["gssapi", "GSSAPI"],
+  ["plain", "PLAIN"],
+  ["scramSha256", "SCRAM-SHA-256"],
+  ["scramSha512", "SCRAM-SHA-512"],
+]);
+
+/**
+ * The `-X` properties kcat hands librdkafka to reach the server: TLS for
+ * `kafka-secure`, and the first SASL scheme the server declares, with its
+ * credentials read from the environment (Kerberos brings its own).
+ */
+const kafkaSecurityFlags = (server?: AsyncApiServerObject): string[] => {
+  const tls = server?.protocol?.toLowerCase() === "kafka-secure";
+  const mechanism = (server?.security ?? [])
+    .map((entry) => SASL_MECHANISMS.get(String(entry?.type)))
+    .find((value) => value !== undefined);
+  if (mechanism === undefined) {
+    return tls ? ["-X security.protocol=SSL"] : [];
+  }
+  const flags = [
+    `-X security.protocol=${tls ? "SASL_SSL" : "SASL_PLAINTEXT"}`,
+    `-X sasl.mechanisms=${mechanism}`,
+  ];
+  if (mechanism !== "GSSAPI") {
+    flags.push(
+      '-X sasl.username="$KAFKA_USERNAME"',
+      '-X sasl.password="$KAFKA_PASSWORD"'
+    );
+  }
+  return flags;
+};
+
+/**
+ * The separator between key and value: kcat splits each produced line at its
+ * first `|`, and prints consumed keys before one.
+ */
+const KEY_DELIMITER = "|";
+
 const kcatSnippet = (sample: MessageSample): string => {
   const broker = sample.server?.host ?? "localhost:9092";
-  const base = `kcat -b ${shellQuote(broker)} -t ${shellQuote(sample.address)}`;
-  return sample.action === "receive"
-    ? `echo ${shellQuote(payloadInline(sample))} | ${base} -P`
-    : `${base} -C`;
+  const mode = sample.action === "receive" ? "-P" : "-C";
+  const keyed =
+    sample.key === undefined ? "" : ` -K ${shellQuote(KEY_DELIMITER)}`;
+  const command = [
+    `kcat -b ${shellQuote(broker)} -t ${shellQuote(sample.address)} ${mode}${keyed}`,
+    ...kafkaSecurityFlags(sample.server),
+  ].join(" \\\n  ");
+  if (sample.action !== "receive") {
+    return command;
+  }
+  const line =
+    sample.key === undefined
+      ? payloadInline(sample)
+      : `${sample.key}${KEY_DELIMITER}${payloadInline(sample)}`;
+  return `echo ${shellQuote(line)} | ${command}`;
 };
 
 const mosquittoSnippet = (sample: MessageSample): string => {

package/src/components/openapi/async.ts

@@ -8,6 +8,8 @@ import type {
 } from "../../openapi/asyncapi.ts";
 import type { ParameterLike, SchemaLike } from "./helpers.ts";
 import { resolveComponentRef } from "./helpers.ts";
+import type { OperationSecurity, SecuritySchemeLike } from "./security.ts";
+import { resolveAsyncApiSecurity } from "./security.ts";
 
 /**
  * Runtime helpers for the AsyncAPI components — the async counterpart of
@@ -239,32 +241,61 @@ export const channelParameters = (
 
 const SERVER_REF = /^#\/servers\/(?<name>[^/]+)$/u;
 
+/** A server paired with its key under the document's `servers`. */
+export interface NamedServer {
+  name: string;
+  server: AsyncApiServerObject;
+}
+
 /**
- * The servers a channel is available on: its `servers` refs when declared,
- * else every server the document declares (the spec's default).
+ * The servers a channel is available on, by name: its `servers` refs when
+ * declared, else every server the document declares (the spec's default).
  */
-export const channelServers = (
+export const namedChannelServers = (
   channel: AsyncApiChannelObject | undefined,
   document: AsyncApiDocument
-): AsyncApiServerObject[] => {
+): NamedServer[] => {
   const all = document.servers ?? {};
   const refs = channel?.servers;
   if (!Array.isArray(refs) || refs.length === 0) {
-    return Object.values(all).filter(isObject);
+    return Object.entries(all).flatMap(([name, server]) =>
+      isObject(server) ? [{ name, server }] : []
+    );
   }
-  const servers: AsyncApiServerObject[] = [];
+  const servers: NamedServer[] = [];
   for (const ref of refs) {
-    const name = SERVER_REF.exec(
+    const pointer = SERVER_REF.exec(
       isObject(ref) && isString(ref.$ref) ? ref.$ref : ""
     )?.groups?.name;
-    const server = name === undefined ? undefined : all[unescapePointer(name)];
-    if (isObject(server)) {
-      servers.push(server);
+    const name = pointer === undefined ? undefined : unescapePointer(pointer);
+    const server = name === undefined ? undefined : all[name];
+    if (name !== undefined && isObject(server)) {
+      servers.push({ name, server });
     }
   }
   return servers;
 };
 
+/**
+ * A server's `security` entries with their `$ref`s into
+ * `components.securitySchemes` resolved (non-objects dropped), for the
+ * samples, which read the scheme off the server they're built from.
+ */
+export const resolvedServerSecurity = (
+  server: AsyncApiServerObject,
+  components?: Components
+): AsyncApiRefLike[] =>
+  (Array.isArray(server.security) ? server.security : [])
+    .filter(isObject)
+    .map((entry) => resolveComponentRef(entry, components, "securitySchemes"));
+
+/** The servers a channel is available on; see {@link namedChannelServers}. */
+export const channelServers = (
+  channel: AsyncApiChannelObject | undefined,
+  document: AsyncApiDocument
+): AsyncApiServerObject[] =>
+  namedChannelServers(channel, document).map(({ server }) => server);
+
 /** A protocol-keyed `bindings` map, whatever object it sits on. */
 type BindingMap = Record<string, AsyncApiSpecValue>;
 
@@ -291,6 +322,34 @@ export const resolveBindings = (
   return isObject(target) ? target : undefined;
 };
 
+/** The `kafka` object of a bindings map, a `$ref`'d map resolved. */
+const kafkaBinding = (
+  bindings: BindingMap | undefined,
+  components?: Components
+): Record<string, AsyncApiSpecValue> | undefined => {
+  const kafka = resolveBindings(bindings, components)?.kafka;
+  return isObject(kafka) ? kafka : undefined;
+};
+
+/**
+ * A Kafka channel binding's `topic`, which names the topic when it differs
+ * from the channel address. The samples produce to and consume from it.
+ */
+export const kafkaTopic = (
+  channel: AsyncApiChannelObject | undefined,
+  components?: Components
+): string | undefined => {
+  const topic = kafkaBinding(channel?.bindings, components)?.topic;
+  return isString(topic) && topic !== "" ? topic : undefined;
+};
+
+/** The schema of a message's Kafka key (its `kafka` binding's `key`). */
+export const kafkaKeySchema = (
+  message: AsyncApiMessageLike | undefined,
+  components?: Components
+): SchemaLike | undefined =>
+  schemaOf(kafkaBinding(message?.bindings, components)?.key);
+
 /** Normalize protocol spellings onto the binding key they document. */
 const PROTOCOL_ALIASES = {
   "kafka-secure": "kafka",
@@ -326,35 +385,70 @@ export const protocolOf = (
 };
 
 /**
- * The security list an operation actually enforces: its own `security` when
- * declared, else the union of its servers' — connecting already requires the
- * server's schemes. Server entries dedupe by `$ref`, so two servers sharing a
- * scheme render it once.
+ * The security an operation renders: its own `security` when declared, else
+ * the union of its servers' — connecting already requires the server's
+ * schemes. Server entries dedupe by `$ref`, so two servers sharing a scheme
+ * render it once. Each server's list stands alone, though: when the servers
+ * disagree (a production cluster behind SASL beside a local broker with no
+ * security), a scheme only some servers declare names them, and
+ * `unauthenticatedServers` lists the ones that declare none, rather than one
+ * server's scheme reading as required on all of them.
  */
-export const asyncApiSecurityEntries = (
+export const asyncApiSecurity = (
   operation: AsyncApiOperationObject | undefined,
-  servers: AsyncApiServerObject[]
-): AsyncApiRefLike[] => {
+  servers: NamedServer[],
+  schemes: Record<string, SecuritySchemeLike> | undefined
+): OperationSecurity => {
   if (Array.isArray(operation?.security)) {
-    return operation.security;
+    return resolveAsyncApiSecurity(operation.security, schemes);
   }
-  const entries: AsyncApiRefLike[] = [];
-  const seen = new Set<string>();
-  for (const server of servers) {
-    for (const entry of server.security ?? []) {
-      if (!isObject(entry)) {
+  const entries: { entry: AsyncApiRefLike; servers: string[] }[] = [];
+  const byRef = new Map<string, string[]>();
+  const unauthenticated: string[] = [];
+  for (const { name, server } of servers) {
+    const declared = Array.isArray(server.security)
+      ? server.security.filter(isObject)
+      : [];
+    if (declared.length === 0) {
+      unauthenticated.push(name);
+    }
+    for (const entry of declared) {
+      const shared = isString(entry.$ref) ? byRef.get(entry.$ref) : undefined;
+      if (shared) {
+        shared.push(name);
         continue;
       }
+      const names = [name];
       if (isString(entry.$ref)) {
-        if (seen.has(entry.$ref)) {
-          continue;
-        }
-        seen.add(entry.$ref);
+        byRef.set(entry.$ref, names);
       }
-      entries.push(entry);
+      entries.push({ entry, servers: names });
     }
   }
-  return entries;
+  const agree =
+    entries.length === 0 ||
+    (unauthenticated.length === 0 &&
+      entries.every((item) => item.servers.length === servers.length));
+  if (agree) {
+    return resolveAsyncApiSecurity(
+      entries.map(({ entry }) => entry),
+      schemes
+    );
+  }
+  return {
+    // A scheme every server declares needs no server list of its own.
+    alternatives: entries.map(({ entry, servers: names }) =>
+      resolveAsyncApiSecurity([entry], schemes)
+        .alternatives.flat()
+        .map((resolved) =>
+          names.length === servers.length
+            ? resolved
+            : { ...resolved, servers: names }
+        )
+    ),
+    optional: false,
+    unauthenticatedServers: unauthenticated,
+  };
 };
 
 /** One protocol's binding fields, ready for a key/value table. */

package/src/components/openapi/graphql-helpers.ts

@@ -10,8 +10,11 @@ import {
   isGraphqlOperationKind,
 } from "../../openapi/graphql.ts";
 import type { ApiSpecData } from "../../openapi/model.ts";
+import { endpointSecurity } from "../content/api-page.ts";
 import type { SpecValue } from "./helpers.ts";
+import { playgroundAuth } from "./operation-model.ts";
 import type { PlaygroundModel } from "./request.ts";
+import type { OperationSecurity } from "./security.ts";
 
 /**
  * Build-time logic behind the GraphQL reference pages: the generated example
@@ -67,9 +70,10 @@ const isComposite = (document: GraphqlDocument, name: string): boolean => {
 
 /**
  * A valid selection set for a composite type, or undefined for leaves: every
- * scalar/enum field, plus nested composites while `depth` allows. A composite
- * with nothing selectable at this depth falls back to `__typename`, which is
- * legal on any composite — the set must never come out empty.
+ * scalar/enum field, plus nested composites while `depth` allows, deprecated
+ * fields left out so the example doesn't teach them. A composite with nothing
+ * selectable at this depth falls back to `__typename`, which is legal on any
+ * composite — the set must never come out empty.
  */
 export const selectionSet = (
   document: GraphqlDocument,
@@ -85,10 +89,12 @@ export const selectionSet = (
   }
   const selections: GraphqlSelection[] = [];
   for (const field of type.fields ?? []) {
-    // A field with an argument that must be supplied — non-null and no
-    // default — can't ride an example selection; there is nothing valid to
-    // fill it with inline. A defaulted non-null argument is omittable.
+    // A deprecated field stays out of the example. So does a field with an
+    // argument that must be supplied — non-null and no default: there is
+    // nothing valid to fill it with inline. A defaulted non-null argument is
+    // omittable.
     if (
+      field.deprecationReason !== undefined ||
       field.args.some(
         (arg) => arg.type.display.endsWith("!") && arg.default === undefined
       )
@@ -189,10 +195,14 @@ const sampleForRef = (
   if (type?.kind === "enum") {
     named = type.enumValues?.[0]?.name ?? null;
   } else if (type?.kind === "input" && depth > 0) {
+    // A field with a default starts at it, the value a client leaving it
+    // out gets.
     named = Object.fromEntries(
       (type.inputFields ?? []).map((field) => [
         field.name,
-        sampleForRef(document, field.type, depth - 1),
+        field.defaultValue === undefined
+          ? sampleForRef(document, field.type, depth - 1)
+          : field.defaultValue,
       ])
     );
   } else if (type?.kind === "input") {
@@ -203,7 +213,10 @@ const sampleForRef = (
   return wrapLists(ref.display, named);
 };
 
-/** Example `variables` for a root field's arguments; undefined when it has none. */
+/**
+ * Example `variables` for a root field's arguments, each starting at its
+ * declared default when it has one; undefined when it has none.
+ */
 export const exampleVariables = (
   document: GraphqlDocument,
   field: GraphqlField
@@ -212,7 +225,9 @@ export const exampleVariables = (
     ? Object.fromEntries(
         field.args.map((arg) => [
           arg.name,
-          sampleForRef(document, arg.type, VARIABLE_DEPTH),
+          arg.defaultValue === undefined
+            ? sampleForRef(document, arg.type, VARIABLE_DEPTH)
+            : arg.defaultValue,
         ])
       )
     : undefined;
@@ -271,19 +286,27 @@ export const exampleResponse = (
   return { data };
 };
 
+/**
+ * The security every operation of a GraphQL reference enforces: its `auth`
+ * option, read the way a hand-written endpoint reads the site's `api.auth`.
+ */
+export const graphqlSecurity = (spec: ApiSpecData): OperationSecurity =>
+  endpointSecurity(undefined, spec.auth);
+
 /**
  * The playground/request model for one GraphQL operation: a plain POST whose
  * JSON body carries the query and variables. Reusing `PlaygroundModel` means
  * the OpenAPI playground UI, its client module, and `buildRequest` all work
- * unchanged — the samples show byte-for-byte what the Send button transmits.
+ * unchanged — the samples show byte-for-byte what the Send button transmits,
+ * the configured `auth` credential included.
  */
 export const graphqlPlaygroundModel = (
   spec: ApiSpecData,
   query: string,
   variables?: GraphqlSampleObject
 ): PlaygroundModel => ({
-  auth: [],
-  authOptional: true,
+  auth: playgroundAuth(graphqlSecurity(spec)),
+  authOptional: false,
   body: {
     contentType: "application/json",
     example: JSON.stringify(

package/src/components/openapi/helpers.ts

@@ -135,7 +135,23 @@ export const mergeParameters = (
 export const refName = (ref: string): string =>
   REF_PATTERN.exec(ref)?.groups?.name ?? ref.split("/").at(-1) ?? ref;
 
-/** Resolve one level of `$ref` against the document's component schemas. */
+/**
+ * The one member of an `allOf` that only wraps it: `allOf: [{ $ref }]` beside
+ * a `description`, `readOnly`, or `default`, which is how drf-spectacular and
+ * other generators attach keywords a 3.0 `$ref` can't carry. `undefined` for
+ * a real composition: several members, or properties or branches of its own.
+ */
+export const soleAllOfMember = (schema: SchemaLike): SchemaLike | undefined =>
+  schema.allOf?.length === 1 &&
+  !(schema.properties || schema.oneOf || schema.anyOf)
+    ? schema.allOf[0]
+    : undefined;
+
+/**
+ * Resolve one level of `$ref` against the document's component schemas. A
+ * single-member `allOf` wrapper resolves like its member, with the wrapper's
+ * own keywords on top: its `description` is about this field.
+ */
 export const resolveSchema = (
   schemas: Record<string, SchemaLike>,
   schema?: SchemaLike
@@ -143,6 +159,11 @@ export const resolveSchema = (
   if (!schema) {
     return {};
   }
+  const member = soleAllOfMember(schema);
+  if (member) {
+    const { allOf: _wrapped, ...own } = schema;
+    return { ...resolveSchema(schemas, member), ...own };
+  }
   if (isString(schema.$ref)) {
     const name = REF_PATTERN.exec(schema.$ref)?.groups?.name;
     if (name && schemas[name]) {
@@ -152,6 +173,16 @@ export const resolveSchema = (
   return schema;
 };
 
+/**
+ * A parameter's description: its own, else its schema's (resolved one `$ref`
+ * level), which is where generators like Elysia and oRPC write it.
+ */
+export const parameterDescription = (
+  param: { description?: string; schema?: SchemaLike },
+  schemas: Record<string, SchemaLike>
+): string | undefined =>
+  param.description ?? resolveSchema(schemas, param.schema).description;
+
 const declaredTypeList = (type: string | string[] | undefined): string[] => {
   if (!type) {
     return [];
@@ -177,6 +208,8 @@ const isNullType = (schema: SchemaLike): boolean => {
  * (`Pet`, `Pet[]`) without resolving — which also means circular refs through
  * array items can't recurse forever. A `null` member stays out of a union's
  * label: rows mark it with {@link isNullable}, as they do `type: [T, "null"]`.
+ * A single-member `allOf` wrapper labels as its member; a real composition is
+ * an `object`.
  */
 export const typeLabel = (schema: SchemaLike): string => {
   if (isString(schema.$ref)) {
@@ -192,7 +225,8 @@ export const typeLabel = (schema: SchemaLike): string => {
     return [...new Set(labels)].join(" | ") || "any";
   }
   if (schema.allOf) {
-    return "object";
+    const member = soleAllOfMember(schema);
+    return member ? typeLabel(member) : "object";
   }
   const types = nonNullTypes(schema.type);
   const arrayLabel = (): string => `${typeLabel(schema.items ?? {})}[]`;

package/src/components/openapi/message-model.ts

@@ -1,10 +1,15 @@
 import type {
   AsyncApiAction,
+  AsyncApiDocument,
   AsyncApiServerObject,
 } from "../../openapi/asyncapi.ts";
 import { withServerDefaults } from "../../openapi/model.ts";
 import type { AsyncApiMessageLike, NamedMessage } from "./async.ts";
-import { payloadSchema } from "./async.ts";
+import {
+  kafkaKeySchema,
+  payloadSchema,
+  resolvedServerSecurity,
+} from "./async.ts";
 import { exampleValue, toJson } from "./helpers.ts";
 import type { ParameterLike, SchemaLike } from "./helpers.ts";
 import type {
@@ -76,14 +81,34 @@ const messagePayload = (
   };
 };
 
+/**
+ * The first message's Kafka key as the kcat sample writes it: sampled from
+ * its binding's `key` schema the way a payload is (a declared example wins),
+ * a non-string value as JSON. None when the message declares no key.
+ */
+const messageKey = (
+  message: AsyncApiMessageLike | undefined,
+  schemas: Record<string, SchemaLike>,
+  components: AsyncApiDocument["components"]
+): string | undefined => {
+  const schema = kafkaKeySchema(message, components);
+  const key = inputValue(schema ? exampleValue(schema, schemas) : null);
+  return key === "" ? undefined : key;
+};
+
 /**
  * A server's base URL for the picker. Falls back to the bare host when the
  * spec omits `protocol` — a label is a label, and the snippet builders read
  * the server object itself rather than this string. Server variables in the
  * host and pathname (`{env}.events.example.com`) resolve to their declared
  * defaults, in the label and in the object the samples and connect URL read.
+ * Security refs resolve here too, so the kcat sample can name the server's
+ * SASL mechanism.
  */
-const serverOption = (spec: AsyncApiServerObject): MessageServerOption => {
+const serverOption = (
+  spec: AsyncApiServerObject,
+  components: AsyncApiDocument["components"]
+): MessageServerOption => {
   const server = { ...spec };
   if (spec.host !== undefined) {
     server.host = withServerDefaults(spec.host, spec.variables);
@@ -91,6 +116,9 @@ const serverOption = (spec: AsyncApiServerObject): MessageServerOption => {
   if (spec.pathname !== undefined) {
     server.pathname = withServerDefaults(spec.pathname, spec.variables);
   }
+  if (spec.security !== undefined) {
+    server.security = resolvedServerSecurity(spec, components);
+  }
   const host = `${server.host ?? ""}${server.pathname ?? ""}`;
   return {
     label: server.protocol ? `${server.protocol}://${host}` : host,
@@ -102,17 +130,32 @@ const serverOption = (spec: AsyncApiServerObject): MessageServerOption => {
 export const messageModel = (args: {
   action: AsyncApiAction;
   address: string;
+  /** The document's `components`, which bindings and security refs resolve against. */
+  components?: AsyncApiDocument["components"];
   messages: NamedMessage[];
   parameters: ParameterLike[];
   protocol?: string;
   schemas: Record<string, SchemaLike>;
   servers: AsyncApiServerObject[];
-}): MessageModel => ({
-  action: args.action,
-  address: args.address,
-  connectable: Object.hasOwn(LIVE_PROTOCOLS, args.protocol ?? ""),
-  params: messageParams(args.parameters),
-  payload: messagePayload(args.messages[0]?.message, args.schemas),
-  protocol: args.protocol,
-  servers: args.servers.map(serverOption),
-});
+}): MessageModel => {
+  const model: MessageModel = {
+    action: args.action,
+    address: args.address,
+    connectable: Object.hasOwn(LIVE_PROTOCOLS, args.protocol ?? ""),
+    params: messageParams(args.parameters),
+    payload: messagePayload(args.messages[0]?.message, args.schemas),
+    protocol: args.protocol,
+    servers: args.servers.map((server) =>
+      serverOption(server, args.components)
+    ),
+  };
+  const key = messageKey(
+    args.messages[0]?.message,
+    args.schemas,
+    args.components
+  );
+  if (key !== undefined) {
+    model.key = key;
+  }
+  return model;
+};