@amritk/asyncapi 0.1.0

package/dist/schema-format.js

@@ -0,0 +1,20 @@
+const ASYNCAPI_DIALECT = /^application\/vnd\.aai\.asyncapi([+;]|$)/;
+const OPENAPI_DIALECT = /^application\/vnd\.oai\.openapi([+;]|$)/;
+const JSON_SCHEMA_DIALECT = /^application\/schema\+(?:json|yaml);\s*version=(draft-07|draft-2020-12)\s*$/;
+const classifySchemaFormat = (schemaFormat) => {
+  if (schemaFormat === void 0)
+    return "asyncapi";
+  if (typeof schemaFormat !== "string")
+    return "unsupported";
+  if (ASYNCAPI_DIALECT.test(schemaFormat))
+    return "asyncapi";
+  if (OPENAPI_DIALECT.test(schemaFormat))
+    return "openapi";
+  const jsonSchema = JSON_SCHEMA_DIALECT.exec(schemaFormat);
+  if (jsonSchema)
+    return jsonSchema[1] === "draft-07" ? "draft-07" : "2020-12";
+  return "unsupported";
+};
+export {
+  classifySchemaFormat
+};

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The normalized shape both AsyncAPI majors are extracted into.
+ *
+ * The model is 3.0-shaped: 2.x documents are mapped onto it during extraction
+ * (`publish`/`subscribe` become `receive`/`send`, sibling `schemaFormat` keys
+ * become per-schema classifications) so every consumer sees one structure
+ * regardless of which major the author wrote.
+ */
+/**
+ * A problem found while extracting, tied to the document location it was found
+ * at. Issues are collected rather than thrown: a document with one Avro payload
+ * still yields every JSON-Schema payload it declares, and the caller decides
+ * whether the skipped parts are worth failing over.
+ */
+export type ExtractionIssue = {
+    /** JSON-Pointer-ish location of the problem (e.g. `#/channels/foo/messages/bar`). */
+    readonly path: string;
+    readonly message: string;
+};
+/**
+ * Which way a message flows, named from the application's point of view — the
+ * same convention `@amritk/api` uses. AsyncAPI 2.x's `publish` (clients
+ * publish, the application receives) maps to `receive`; `subscribe` maps to
+ * `send`; 3.0's `action` is already spelled this way.
+ */
+export type MessageDirection = 'send' | 'receive';
+/** One message on a channel, its schemas already normalized to JSON Schema 2020-12. */
+export type NormalizedMessage = {
+    /**
+     * The message's identity: the 3.0 channel-messages key, or in 2.x the
+     * message `name`, falling back to `messageId` and then a positional
+     * `message-<n>`. Doubles as the wire discriminator value in a later
+     * message-contract projection.
+     */
+    readonly name: string;
+    /** Key of the channel the message was declared on. */
+    readonly channelKey: string;
+    /** Absent when no operation names the message, so its flow is undeclared. */
+    readonly direction?: MessageDirection;
+    readonly contentType?: string;
+    /**
+     * The declared payload `schemaFormat`, kept verbatim (absent = the AsyncAPI
+     * default dialect) so a consumer can see *why* a payload was or was not
+     * extracted.
+     */
+    readonly schemaFormat?: string;
+    /**
+     * The payload as a self-contained JSON Schema 2020-12 document: the dialect
+     * normalized, and every `#/components/schemas/...` reference rebased into a
+     * local `$defs`. Absent when the message declares none, or when its
+     * `schemaFormat` is not a JSON Schema dialect (an issue records which).
+     */
+    readonly payload?: Record<string, unknown>;
+    /** The headers schema, normalized the same way as {@link payload}. */
+    readonly headers?: Record<string, unknown>;
+};
+export type NormalizedChannel = {
+    /** The channel's key in the document's `channels` map. */
+    readonly key: string;
+    /** The 3.0 `address`; for 2.x the channel key, which *is* the topic/path. */
+    readonly address?: string;
+    readonly messages: readonly NormalizedMessage[];
+};
+export type AsyncApiModel = {
+    /** The declared `asyncapi` version, verbatim (e.g. `2.6.0`, `3.0.0`). */
+    readonly version: string;
+    readonly major: 2 | 3;
+    /** The document's `info.title`, when it is a string. */
+    readonly title?: string;
+    readonly channels: readonly NormalizedChannel[];
+    readonly issues: readonly ExtractionIssue[];
+};
+/**
+ * One generatable schema pulled out of the model: what to hand `buildSchema`
+ * and where its output tree belongs, mirroring how `--schema-dir` maps each
+ * schema file to its own subdirectory.
+ */
+export type ExtractedSchema = {
+    /** Output subdirectory, e.g. `channels/user-signed-up/user-event`. */
+    readonly subDir: string;
+    /** PascalCase root type name derived from the message identity, not the schema `title`. */
+    readonly rootTypeName: string;
+    readonly schema: Record<string, unknown>;
+};

package/dist/unwrap-multi-format.d.ts

@@ -0,0 +1,14 @@
+export type UnwrappedSchema = {
+    /** The wrapper's `schemaFormat`, or `undefined` when the node was a bare schema. */
+    readonly schemaFormat?: unknown;
+    readonly schema: unknown;
+};
+/**
+ * Unwraps an AsyncAPI 3.0 Multi Format Schema Object (`{ schemaFormat,
+ * schema }`) into its parts, passing a bare Schema Object through untouched.
+ *
+ * The wrapper is recognized only when *both* keys are present: `schemaFormat`
+ * is required on the wrapper, and demanding `schema` too keeps a plain schema
+ * that merely declares a property named `schemaFormat` from losing its body.
+ */
+export declare const unwrapMultiFormat: (node: unknown) => UnwrappedSchema;

package/dist/unwrap-multi-format.js

@@ -0,0 +1,14 @@
+import { readKey } from "@amritk/helpers/read-key";
+const unwrapMultiFormat = (node) => {
+  if (typeof node === "object" && node !== null && !Array.isArray(node)) {
+    const record = node;
+    const schemaFormat = readKey(record, "schemaFormat");
+    if (schemaFormat !== void 0 && Object.hasOwn(record, "schema")) {
+      return { schemaFormat, schema: readKey(record, "schema") };
+    }
+  }
+  return { schema: node };
+};
+export {
+  unwrapMultiFormat
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@amritk/asyncapi",
+  "version": "0.1.0",
+  "description": "Extract JSON Schemas from AsyncAPI 2.x/3.0 documents for the mjst generators.",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "author": "amritk",
+  "keywords": [
+    "asyncapi",
+    "json-schema",
+    "typescript",
+    "codegen",
+    "mjst"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amritk/mjst.git",
+    "directory": "packages/asyncapi"
+  },
+  "homepage": "https://github.com/amritk/mjst/tree/main/packages/asyncapi#readme",
+  "bugs": {
+    "url": "https://github.com/amritk/mjst/issues"
+  },
+  "files": [
+    "dist",
+    "AI.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json && tsc-alias -p tsconfig.build.json -f && node ../../scripts/strip-comments.mjs",
+    "prepublishOnly": "node ../../scripts/check-publishable.mjs",
+    "types:check": "tsgo -p . --noEmit",
+    "test": "NODE_ENV=production vitest run --root ../.. packages/asyncapi"
+  },
+  "dependencies": {
+    "@amritk/helpers": "^0.19.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*.d.ts"
+      ]
+    }
+  }
+}