@hatua/schema 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,335 @@
+import { z as e } from "zod";
+//#region src/generated/component.ts
+var t = e.strictObject({
+	kind: e.enum(["component", "trigger"]),
+	use: e.string().min(1),
+	name: e.string().min(1),
+	group: e.string().optional(),
+	icon: e.string().min(1).optional(),
+	blurb: e.string().optional(),
+	once: e.boolean().optional(),
+	fixed: e.boolean().optional(),
+	get fields() {
+		return e.array(n);
+	},
+	get outputs() {
+		return e.array(r);
+	},
+	get metadata() {
+		return e.array(i).optional();
+	}
+}), n = e.strictObject({
+	k: e.string().min(1),
+	label: e.string().min(1),
+	kind: e.enum([
+		"text",
+		"mono",
+		"number",
+		"textarea",
+		"ref",
+		"map",
+		"enum",
+		"bool",
+		"conn",
+		"secret"
+	]),
+	conn_type: e.string().optional(),
+	req: e.boolean().optional(),
+	hint: e.string().optional(),
+	ph: e.string().optional(),
+	mono: e.boolean().optional(),
+	options: e.array(e.strictObject({
+		value: e.string(),
+		label: e.string(),
+		hint: e.string().optional()
+	})).optional(),
+	toggleLabel: e.string().optional(),
+	entry_types: e.array(e.enum([
+		"text",
+		"number",
+		"boolean",
+		"datetime",
+		"list",
+		"object"
+	])).optional(),
+	when: e.array(e.string()).min(2).max(2).optional()
+}), r = e.strictObject({
+	k: e.string().min(1),
+	label: e.string().min(1),
+	t: e.enum([
+		"text",
+		"number",
+		"boolean",
+		"datetime",
+		"object",
+		"list",
+		"item"
+	]),
+	get of() {
+		return e.array(r).optional();
+	}
+}), i = e.strictObject({
+	k: e.string().min(1),
+	label: e.string().min(1),
+	t: e.enum([
+		"text",
+		"number",
+		"boolean",
+		"datetime"
+	]),
+	role: e.enum(["measure", "dimension"]),
+	unit: e.string().optional()
+}), a = e.union([t, e.strictObject({ get components() {
+	return e.array(t);
+} })]), o = e.strictObject({
+	k: e.string().regex(/^[a-z][a-z0-9_]*$/),
+	label: e.string().min(1),
+	t: e.enum([
+		"text",
+		"number",
+		"boolean",
+		"datetime",
+		"object",
+		"list"
+	]),
+	description: e.string().optional(),
+	get of() {
+		return e.array(o).optional();
+	}
+}), s = e.strictObject({
+	kind: e.enum(["context"]),
+	get keys() {
+		return e.array(o);
+	}
+}), c = e.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), l = e.strictObject({
+	get id() {
+		return c;
+	},
+	name: e.string().optional(),
+	get params() {
+		return e.array(u).optional();
+	},
+	get outputs() {
+		return e.array(u).optional();
+	},
+	get vars() {
+		return e.array(p).optional();
+	},
+	get steps() {
+		return e.array(m);
+	}
+}), u = e.strictObject({
+	get k() {
+		return c;
+	},
+	label: e.string().min(1),
+	t: e.enum([
+		"text",
+		"number",
+		"boolean",
+		"datetime",
+		"object",
+		"list"
+	]),
+	get of() {
+		return e.array(u).optional();
+	}
+}), d = e.strictObject({
+	id: e.string().min(1),
+	ref: e.string().nullable()
+}), f = e.strictObject({
+	get id() {
+		return c;
+	},
+	use: e.string().min(1),
+	name: e.string().optional(),
+	get with() {
+		return g.optional();
+	}
+}), p = e.strictObject({
+	get key() {
+		return c;
+	},
+	t: e.enum([
+		"text",
+		"number",
+		"boolean",
+		"datetime",
+		"object",
+		"list"
+	]),
+	get of() {
+		return e.array(u).optional();
+	},
+	value: e.unknown()
+}), m = e.strictObject({
+	get id() {
+		return c;
+	},
+	use: e.string().min(1),
+	name: e.string().optional(),
+	get with() {
+		return g.optional();
+	},
+	get branches() {
+		return e.array(h).min(1).optional();
+	},
+	get steps() {
+		return e.array(m).optional();
+	},
+	get handler() {
+		return e.array(m).optional();
+	},
+	until: e.string().optional()
+}), h = e.strictObject({
+	label: e.string(),
+	when: e.string().optional(),
+	get steps() {
+		return e.array(m);
+	}
+}), g = e.record(e.string(), e.unknown()), _ = e.strictObject({
+	id: e.string().min(1),
+	name: e.string(),
+	version: e.number().int().min(1),
+	status: e.enum([
+		"published",
+		"draft",
+		"archived"
+	]),
+	get connections() {
+		return e.array(d).optional();
+	},
+	get triggers() {
+		return e.array(f).optional();
+	},
+	get vars() {
+		return e.array(p).optional();
+	},
+	get blocks() {
+		return e.array(l).optional();
+	},
+	get steps() {
+		return e.array(m);
+	}
+}), v = e.strictObject({
+	id: e.string().min(1),
+	status: e.enum([
+		"pending",
+		"running",
+		"succeeded",
+		"failed",
+		"skipped"
+	]),
+	duration_ms: e.number().min(0).optional(),
+	resolved_input: e.unknown().optional(),
+	output: e.unknown().optional(),
+	metadata: e.record(e.string(), e.unknown()).optional(),
+	get error() {
+		return b.optional();
+	},
+	get iterations() {
+		return e.array(y).optional();
+	}
+}), y = e.strictObject({
+	index: e.number().int().min(0),
+	status: e.enum([
+		"pending",
+		"running",
+		"succeeded",
+		"failed",
+		"skipped"
+	]),
+	duration_ms: e.number().min(0).optional(),
+	get steps() {
+		return e.array(v).optional();
+	},
+	get error() {
+		return b.optional();
+	}
+}), b = e.strictObject({
+	message: e.string(),
+	code: e.string().optional()
+}), x = e.strictObject({
+	at: e.iso.datetime({ offset: !0 }),
+	step: e.string().optional(),
+	channel: e.string().optional(),
+	message: e.string()
+}), S = e.strictObject({
+	run_id: e.string().min(1),
+	status: e.enum([
+		"running",
+		"succeeded",
+		"failed"
+	]),
+	workflow: e.strictObject({
+		id: e.string().min(1),
+		version: e.number().int().min(1)
+	}),
+	trigger: e.strictObject({
+		id: e.string().min(1),
+		payload: e.record(e.string(), e.unknown()).optional()
+	}).optional(),
+	started_at: e.iso.datetime({ offset: !0 }),
+	finished_at: e.iso.datetime({ offset: !0 }).optional(),
+	duration_ms: e.number().min(0).optional(),
+	get steps() {
+		return e.array(v);
+	},
+	get log() {
+		return e.array(x).optional();
+	}
+}), C = e.strictObject({
+	kind: e.enum(["function"]),
+	namespace: e.string().regex(/^[a-z][a-z0-9_]*$/),
+	summary: e.string().optional(),
+	get functions() {
+		return e.array(w).min(1);
+	}
+}), w = e.strictObject({
+	name: e.string().regex(/^[a-z][a-z0-9_]*$/),
+	summary: e.string().optional(),
+	get params() {
+		return e.array(T).optional();
+	},
+	get returns() {
+		return E;
+	}
+}), T = e.strictObject({
+	name: e.string().regex(/^[a-z][a-z0-9_]*$/),
+	get type() {
+		return E;
+	},
+	description: e.string().optional(),
+	optional: e.boolean().optional(),
+	variadic: e.boolean().optional()
+}), E = e.enum([
+	"text",
+	"number",
+	"boolean",
+	"datetime",
+	"list",
+	"object",
+	"item",
+	"unknown",
+	"null"
+]), D = e.union([C, e.strictObject({ get namespaces() {
+	return e.array(C);
+} })]), O = "TRIGGER", k = [
+	"text",
+	"mono",
+	"number",
+	"textarea",
+	"ref",
+	"map"
+], A = (e) => k.includes(e);
+function j(e) {
+	if (typeof e != "object" || !e) return null;
+	let t = e.kind;
+	return t === "component" || t === "trigger" || t === "context" ? t : null;
+}
+var M = (e) => e.filter((e) => {
+	let t = j(e);
+	return t === "component" || t === "trigger";
+}), N = (e) => e.flatMap((e) => j(e) === "context" ? e.keys ?? [] : []);
+//#endregion
+export { k as MAPPABLE_FIELD_KINDS, O as TRIGGER_BUILTIN, l as block, h as branch, a as componentManifest, d as connection, o as contextKey, N as contextKeysIn, u as declaration, j as entryKind, b as error, n as field, D as functionManifest, C as functionNamespace, w as functionSpec, c as identifier, A as isMappable, y as iteration, x as logEntry, t as manifest, M as manifestsIn, i as metadataDescriptor, r as output, T as param, s as runContextManifest, m as step, v as stepExecution, f as trigger, E as valueType, g as values, p as variable, _ as workflowDefinition, S as workflowExecution };

package/dist/references.d.ts

@@ -0,0 +1,77 @@
+import { ContextKey, Manifest, RunContextManifest } from './generated';
+/**
+ * What a mappable field is, and the one built-in name.
+ *
+ * There is deliberately no `REFERENCE_PATTERN` regex here. A regex would be a
+ * second definition of what a Reference is, and two definitions of one thing
+ * disagree eventually — a pattern loose enough to match `{{ steps.s2.count }}` also
+ * matches `{{ a + b }}` and calls the whole thing a reference path.
+ *
+ * A Reference is an AST shape — `isReference()` in `@hatua/expressions` —
+ * and this file keeps only what the schema layer genuinely owns.
+ */
+/**
+ * The built-in holding the id of whichever Trigger actually fired. Needed
+ * because a workflow may declare several triggers with different payloads, so
+ * an expression has to be able to branch on which one started this run.
+ */
+export declare const TRIGGER_BUILTIN = "TRIGGER";
+/**
+ * Field kinds whose value is a Template. The rest hold literal values only.
+ *
+ * `map` is here because each of its entries holds one, even though the field
+ * itself holds a list rather than a string.
+ */
+export declare const MAPPABLE_FIELD_KINDS: readonly ["text", "mono", "number", "textarea", "ref", "map"];
+export declare const isMappable: (kind: string) => boolean;
+/**
+ * One entry of the flat array a Host serves.
+ *
+ * A Component Manifest declares a step type or a trigger type; a Run Context
+ * Manifest declares the ambient values the Host supplies to every execution.
+ * They travel together because they answer the same question — *what has this
+ * Host declared?* — and splitting them would buy a second store, a second
+ * loading state and a second failure state for a payload that is a handful of
+ * typed keys.
+ *
+ * **This union is discriminated and the parse-time one is not**, which is the
+ * whole difference. `ComponentManifest` is "one manifest OR a `components:`
+ * catalogue": its second arm carries no `kind`, so `[{ components: [...] }]`
+ * satisfies it, typechecks, and is then dropped by every consumer that reaches
+ * for `.kind`. Every arm here is an object with a required literal `kind`, so
+ * the catalogue shape satisfies neither arm and a Host serving one is told so
+ * by the compiler rather than by an empty screen. `entryKind()` is the runtime
+ * half of the same guarantee, for the endpoint that breaks the promise anyway.
+ */
+export type ManifestEntry = Manifest | RunContextManifest;
+/**
+ * What an entry declares, or null when it declares nothing this build knows.
+ *
+ * Null is not the same as invalid: a Host serving an entry from a newer
+ * contract than the one embedded here should lose that entry, not the whole
+ * catalogue. What is *not* null-able is the check itself — an entry with no
+ * `kind` at all is the wiring mistake this exists to name.
+ */
+export declare function entryKind(entry: unknown): ManifestEntry['kind'] | null;
+/**
+ * The Component Manifests among the entries — step types and trigger types
+ * alike.
+ *
+ * Through `entryKind`, which is the point of it: the store deliberately passes
+ * an entry it cannot read straight through, saying so by name — "a `kind` from
+ * a newer contract, a name the Host left off, an outright `null`" — because one
+ * bad row must not empty a catalogue. Reaching for `.kind` on that row instead
+ * throws from render and takes down the Host's tree, which is the outcome the
+ * store's `failed` state exists to avoid.
+ */
+export declare const manifestsIn: (entries: readonly ManifestEntry[]) => Manifest[];
+/**
+ * The Run Context keys among the entries, flattened.
+ *
+ * Flattened rather than "the first `kind: context` entry" because nothing stops
+ * a Host assembling its array from several sources, and one declaration
+ * silently winning over another is the failure a `use` collision would be.
+ * Keys are addressed as `run.<k>`, so a duplicate `k` is the Host's to resolve;
+ * `boardScope` takes the first, the way every other lookup here does.
+ */
+export declare const contextKeysIn: (entries: readonly ManifestEntry[]) => ContextKey[];

package/package.json

@@ -1,17 +1,37 @@
 {
   "name": "@hatua/schema",
-  "version": "0.0.0",
-  "description": "Placeholder reserving the name. Nothing is published here; see 0.1.0 and later.",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Internal to @hatua/react — published because it is an external of its build, not a supported API. Workflow Definition and Workflow Execution contract types and validation.",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pedromvgomes/hatua.git",
     "directory": "source/packages/schema"
   },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "yaml": "^2.9.0"
+  },
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage --coverage.reporter=text-summary --coverage.reporter=json-summary --coverage.reporter=lcovonly --passWithNoTests"
+  }
 }

package/README.md

@@ -1,5 +0,0 @@
-# @hatua/schema
-
-This version reserves the package name and contains no code.
-
-Install `0.1.0` or later.