@bakers-build/message 0.0.0-stage → 0.1.0-next.38

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 keytec GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @bakers-build/message
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The InboxMessageHandler contract: a message type's definition (label, access, optional input) and its handler's one-Markdown result. Owns only the message shape, independent of addon/workspace/conductor concepts.
+
+Part of the bakers.build CLI. Install the meta package `@bakers-build/bakers` to get the `bakers` CLI with all addons. Source: https://git.key-tec.de/bakers-build/bakers-build (bakers-cli/).

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export { type FieldType, MESSAGE_CONTRACT_VERSION, type MessageDefinition, type MessageField, type MessageInput, type MessageResult, payloadSchema, type Validation, validateArgs, validateMessageDefinition, validateResult, } from './schema.js';

package/dist/src/index.js

@@ -0,0 +1 @@
+export { MESSAGE_CONTRACT_VERSION, payloadSchema, validateArgs, validateMessageDefinition, validateResult, } from './schema.js';

package/dist/src/schema.d.ts

@@ -0,0 +1,43 @@
+export declare const MESSAGE_CONTRACT_VERSION = 2;
+export type FieldType = 'string' | 'integer' | 'number' | 'boolean';
+export interface MessageField {
+    type: FieldType;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    enum?: Array<string | number>;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: 'uri' | 'multiline';
+}
+export interface MessageInput {
+    type: 'object';
+    required?: string[];
+    properties: Record<string, MessageField>;
+}
+/** What an addon registers for one message type. */
+export interface MessageDefinition {
+    label: string;
+    /** Required access the sender must hold; defaults to the strictest, `update`. */
+    access?: 'view' | 'update';
+    /** Absent means a parameterless message: no form field, no payload. */
+    input?: MessageInput;
+}
+/** What every handler returns: one Markdown answer, nothing else. */
+export interface MessageResult {
+    markdown: string;
+}
+export type Validation = {
+    ok: true;
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare function validateMessageDefinition(def: unknown): Validation;
+/** The message's input as a closed schema; no input means an empty object. */
+export declare function payloadSchema(input: MessageInput | undefined): object;
+export declare function validateArgs(input: MessageInput | undefined, args: unknown): Validation;
+export declare function validateResult(result: unknown): Validation;

package/dist/src/schema.js

@@ -0,0 +1,113 @@
+/**
+ * The message contract v2: a MessageDefinition an addon registers under a
+ * message type key, and the MessageResult its handler answers with. Owns
+ * only the message shape — no addon, workspace or conductor concept lives
+ * here.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Ajv } from 'ajv';
+export const MESSAGE_CONTRACT_VERSION = 2;
+/** Walks up from this module to the `@bakers-build/message` package root (src or dist). */
+function schemaDir() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+            if (pkg.name === '@bakers-build/message')
+                return join(dir, 'schemas');
+        }
+        catch { }
+        dir = dirname(dir);
+    }
+    throw new Error('message/schema: @bakers-build/message package root not found');
+}
+function loadSchema(file) {
+    return JSON.parse(readFileSync(join(schemaDir(), file), 'utf8'));
+}
+let compiled;
+function validators() {
+    if (compiled)
+        return compiled;
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    compiled = {
+        ajv,
+        definition: ajv.compile(loadSchema('message-definition.v2.schema.json')),
+        result: ajv.compile(loadSchema('message-result.v2.schema.json')),
+    };
+    return compiled;
+}
+function ajvErrors(errors) {
+    return (errors ?? []).map((e) => `${e.instancePath.replace(/^\//, '').replaceAll('/', '.') || '(root)'}: ${e.message ?? 'invalid'}`);
+}
+function matchesType(type, value) {
+    switch (type) {
+        case 'integer':
+            return Number.isInteger(value);
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'string':
+            return typeof value === 'string';
+    }
+}
+/** The checks JSON Schema cannot express: values and keywords fit the field type. */
+function consistencyErrors(input) {
+    if (!input)
+        return [];
+    const errors = [];
+    for (const [name, field] of Object.entries(input.properties)) {
+        const at = `input.properties.${name}`;
+        const numeric = field.type === 'integer' || field.type === 'number';
+        if ('default' in field && !matchesType(field.type, field.default))
+            errors.push(`${at}.default: does not match type ${field.type}`);
+        if (field.enum?.some((v) => !matchesType(field.type, v)))
+            errors.push(`${at}.enum: items must match type ${field.type}`);
+        for (const kw of ['minimum', 'maximum'])
+            if (kw in field && !numeric)
+                errors.push(`${at}.${kw}: only allowed on integer or number`);
+        for (const kw of ['minLength', 'maxLength', 'pattern', 'format'])
+            if (kw in field && field.type !== 'string')
+                errors.push(`${at}.${kw}: only allowed on string`);
+        if (field.pattern !== undefined) {
+            try {
+                new RegExp(field.pattern, 'u');
+            }
+            catch {
+                errors.push(`${at}.pattern: does not compile`);
+            }
+        }
+    }
+    for (const name of input.required ?? [])
+        if (!(name in input.properties))
+            errors.push(`input.required: ${name} is not a property`);
+    return errors;
+}
+export function validateMessageDefinition(def) {
+    const { definition } = validators();
+    if (!definition(def))
+        return { ok: false, errors: ajvErrors(definition.errors) };
+    const errors = consistencyErrors(def.input);
+    return errors.length ? { ok: false, errors } : { ok: true };
+}
+/** The message's input as a closed schema; no input means an empty object. */
+export function payloadSchema(input) {
+    return {
+        ...(input ?? { type: 'object', properties: {} }),
+        additionalProperties: false,
+    };
+}
+export function validateArgs(input, args) {
+    const { ajv } = validators();
+    const validate = ajv.compile(payloadSchema(input));
+    const candidate = args === undefined ? {} : args;
+    return validate(candidate)
+        ? { ok: true }
+        : { ok: false, errors: ajvErrors(validate.errors) };
+}
+export function validateResult(result) {
+    const v = validators().result;
+    return v(result) ? { ok: true } : { ok: false, errors: ajvErrors(v.errors) };
+}

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@bakers-build/message",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-next.38",
+  "description": "The InboxMessageHandler contract: a message type's definition (label, access, optional input) and its handler's one-Markdown result. Owns only the message shape, independent of addon/workspace/conductor concepts.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.19"
+  },
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/src",
+    "schemas",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.key-tec.de/bakers-build/bakers-build.git",
+    "directory": "bakers-cli/message"
+  },
+  "dependencies": {
+    "ajv": "^8.20.0"
+  }
+}

package/schemas/message-definition.v2.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://app.bakers.build/schemas/message-definition.v2.schema.json",
+  "title": "MessageDefinition",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["label"],
+  "properties": {
+    "label": { "type": "string", "minLength": 1 },
+    "access": { "enum": ["view", "update"] },
+    "input": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["type", "properties"],
+      "properties": {
+        "type": { "const": "object" },
+        "required": { "type": "array", "items": { "type": "string" } },
+        "properties": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["type"],
+            "properties": {
+              "type": { "enum": ["string", "integer", "number", "boolean"] },
+              "title": { "type": "string" },
+              "description": { "type": "string" },
+              "default": {},
+              "enum": { "type": "array" },
+              "minimum": { "type": "number" },
+              "maximum": { "type": "number" },
+              "minLength": { "type": "integer" },
+              "maxLength": { "type": "integer" },
+              "pattern": { "type": "string" },
+              "format": { "enum": ["uri", "multiline"] }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/schemas/message-result.v2.schema.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://app.bakers.build/schemas/message-result.v2.schema.json",
+  "title": "MessageResult",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["markdown"],
+  "properties": {
+    "markdown": { "type": "string", "maxLength": 1048576 }
+  }
+}