@uipath/maestro-builder-sdk 5.2.0

package/dist/generators/generate_triggers_ts.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Generate statically-typed TypeScript connector-TRIGGER descriptors from the
+canonical trigger catalog (`registry-triggers.json`).
+
+The catalog is IDENTITY ONLY — `{ NodeType, DisplayName, Description, Version,
+connectorKey }` — because a trigger's field schema (`where`/`filters`/output)
+is schema-dynamic: `uip … registry get <trigger>` refuses to return it without a
+live `--connection-id`. So this generator emits DISCOVERY descriptors: one
+`triggerDescriptor()` const per event, carrying its `connector`/`event`/`version`
+so `onEvent`/`waitForEvent` take it in place of the stringly `{ connector, event }`,
+while `where`/output stay loose (`Record<string, string>` / `unknown`). A
+connection-scoped `prepare-trigger` (C4) narrows those later; the surface here is
+unchanged.
+
+One module per connector, mirroring `generate_connectors_ts.py`:
+
+    connectors/<connector-key>.triggers.ts
+      /** Issue Created — (Jira) Trigger when a new issue is created. */
+      export const IssueCreated = triggerDescriptor()({
+        connector: 'uipath-atlassian-jira',
+        event: 'issue-created',
+        version: '1.0.0',
+        displayName: 'Issue Created',
+      } as const);
+
+Usage:
+    generate_triggers_ts.py --triggers <registry-triggers.json> --output <ts-dir>
+                            [--import <specifier>] [--connectors a,b,c]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+TRIGGER_PREFIX = "uipath.connector.trigger."
+
+
+def pascal(event_id: str) -> str:
+    return "".join(w[:1].upper() + w[1:] for w in re.split(r"[^A-Za-z0-9]+", event_id) if w) or "Event"
+
+
+def event_id(node_type: str) -> str:
+    # uipath.connector.trigger.<key>.<event> → <event> (the last dotted segment)
+    return node_type.rsplit(".", 1)[-1]
+
+
+def emit_trigger(t: dict, seen: set) -> list[str]:
+    node_type = t["NodeType"]
+    ev = event_id(node_type)
+    name = pascal(ev)
+    while name in seen:  # de-collide within a connector module
+        name += "_"
+    seen.add(name)
+    version = t.get("Version", "1.0.0")
+    label = t.get("DisplayName") or ev
+    desc = str(t.get("Description") or "").strip().replace("\n", " ")
+
+    doc = f"{label} — {desc}" if desc else label
+    doc = doc.replace("*/", "* /")  # never let a description close the doc comment early
+    lines = [f"/** {doc} */"]
+    lines.append(f"export const {name} = triggerDescriptor()({{")
+    lines.append(f"  connector: {json.dumps(t['connectorKey'])},")
+    lines.append(f"  event: {json.dumps(ev)},")
+    lines.append(f"  version: {json.dumps(version)},")
+    lines.append(f"  displayName: {json.dumps(label)},")
+    lines.append("} as const);")
+    return lines
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--triggers", required=True, help="path to registry-triggers.json")
+    ap.add_argument("--output", required=True)
+    ap.add_argument("--import", dest="imp", default="@uipath/maestro-builder-sdk",
+                    help="module specifier for `import { triggerDescriptor }`")
+    ap.add_argument("--connectors", default="", help="csv subset of connector keys (default: all)")
+    args = ap.parse_args()
+
+    catalog = json.loads(Path(args.triggers).read_text())
+    triggers = catalog["triggers"] if isinstance(catalog, dict) else catalog
+    subset = {c for c in args.connectors.split(",") if c} or None
+
+    by_conn: dict[str, list[dict]] = {}
+    for t in triggers:
+        nt = t.get("NodeType", "")
+        if not nt.startswith(TRIGGER_PREFIX):
+            continue  # catalog is trigger-only, but be defensive
+        ck = t["connectorKey"]
+        if subset and ck not in subset:
+            continue
+        by_conn.setdefault(ck, []).append(t)
+
+    out_dir = Path(args.output)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    written = 0
+    for ck, ts in sorted(by_conn.items()):
+        seen: set = set()
+        body = [f"import {{ triggerDescriptor }} from {json.dumps(args.imp)};", ""]
+        for t in sorted(ts, key=lambda x: x["NodeType"]):
+            body += emit_trigger(t, seen)
+            body.append("")
+        (out_dir / f"{ck}.triggers.ts").write_text("\n".join(body).rstrip() + "\n")
+        written += 1
+    print(f"generated {written} trigger module(s) → {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

package/dist/generators/materialize_registry.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Materialize connector Markdown and TypeScript from canonical library JSON."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--library-json",
+        required=True,
+        help="Canonical connector library directory containing index.json",
+    )
+    parser.add_argument(
+        "--library-md",
+        help="Destination directory for generated Markdown. Omit to skip it — "
+             "the Markdown is a pure function of the library JSON, so there is "
+             "no reason to regenerate 2,472 pages to add one descriptor.",
+    )
+    parser.add_argument(
+        "--connectors",
+        help="Destination directory for generated TypeScript descriptors. "
+             "Omit to skip TypeScript generation: every compiler diagnostic "
+             "comes from the library JSON, so the modules serve an editor's "
+             "autocomplete and a project importing none does not need them.",
+    )
+    parser.add_argument(
+        "--connector-subset",
+        default="",
+        help="Comma-separated connector keys to emit instead of all of them",
+    )
+    parser.add_argument(
+        "--import",
+        dest="module_import",
+        default="@uipath/maestro-builder-sdk",
+        help="Module specifier used by generated TypeScript descriptors",
+    )
+    parser.add_argument(
+        "--triggers",
+        help="Optional registry-triggers.json used to generate trigger descriptors",
+    )
+    return parser.parse_args()
+
+
+def run(script: str, *args: str) -> None:
+    subprocess.run([sys.executable, str(HERE / script), *args], check=True)
+
+
+def main() -> int:
+    args = parse_args()
+    library_json = Path(args.library_json).resolve()
+    library_md = Path(args.library_md).resolve() if args.library_md else None
+    connectors = Path(args.connectors).resolve() if args.connectors else None
+
+    if not (library_json / "index.json").is_file():
+        print(
+            f"materialize-registry: missing {library_json / 'index.json'}",
+            file=sys.stderr,
+        )
+        return 1
+
+    outputs = ([library_md] if library_md else []) + ([connectors] if connectors else [])
+    if library_json in outputs or len(set(outputs)) != len(outputs):
+        print(
+            "materialize-registry: input and output directories must be distinct",
+            file=sys.stderr,
+        )
+        return 1
+
+    if connectors is not None:
+        if connectors.exists():
+            shutil.rmtree(connectors)
+        connectors.mkdir(parents=True)
+
+    if library_md is not None:
+        # Generate beside the target and swap, exactly as pull-cli does for
+        # library-json: the converter wipes and rewrites its output directory,
+        # and two `registry pull`s racing on the shared final path (a coding
+        # agent issues tool calls in parallel) left one of them with
+        # `shutil.rmtree` → "Directory not empty" mid-write (2026-09-01).
+        staging = library_md.with_name(f"{library_md.name}.tmp-{os.getpid()}")
+        if staging.exists():
+            shutil.rmtree(staging)
+        run(
+            "convert_library_to_md.py",
+            "--source",
+            str(library_json),
+            "--output",
+            str(staging),
+        )
+        if staging.is_dir():
+            previous = library_md.with_name(f"{library_md.name}.old-{os.getpid()}")
+            if library_md.exists():
+                library_md.rename(previous)
+            staging.rename(library_md)
+            if previous.exists():
+                shutil.rmtree(previous, ignore_errors=True)
+    if connectors is not None:
+        connectors_args = [
+            "--library", str(library_json),
+            "--output", str(connectors),
+            "--import", args.module_import,
+        ]
+        if args.connector_subset:
+            connectors_args += ["--connectors", args.connector_subset]
+        run("generate_connectors_ts.py", *connectors_args)
+
+    if connectors is not None and args.triggers:
+        triggers = Path(args.triggers).resolve()
+        if not triggers.is_file():
+            print(
+                f"materialize-registry: missing trigger catalog {triggers}",
+                file=sys.stderr,
+            )
+            return 1
+        run(
+            "generate_triggers_ts.py",
+            "--triggers",
+            str(triggers),
+            "--output",
+            str(connectors),
+            "--import",
+            args.module_import,
+        )
+
+    markdown_count = (
+        sum(1 for path in library_md.rglob("*.md") if path.is_file())
+        if library_md is not None
+        else 0
+    )
+    connector_count = (
+        sum(1 for path in connectors.glob("*.ts") if path.is_file())
+        if connectors is not None
+        else 0
+    )
+    print(
+        "materialize-registry: "
+        f"generated {markdown_count} markdown file(s) and "
+        f"{connector_count} TypeScript module(s)"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())