@scemoon/cdh 1.0.7 → 1.0.9-beta.1

package/cdh/generators/rust/MANIFEST.toml

@@ -0,0 +1,18 @@
+[plugin]
+name = "rust"
+display_name = "Rust"
+file_extension = ".rs"
+mime_type = "text/x-rust"
+default_outdir = "rust"
+output_filename_template = "{name}.rs"
+package_name_default = "types"
+
+[features]
+enums = true
+allOf = true
+oneOf = true
+anyOf = true
+nullable = true
+readOnly = true
+writeOnly = true
+format_hints = ["date-time", "uuid", "email", "uri", "double"]

package/cdh/generators/rust/template.rs.tmpl

@@ -0,0 +1,16 @@
+// Auto-generated from {{.SourceFile}}
+use serde::{Deserialize, Serialize};
+use serde_json;
+{{if .HasDateTime}}use chrono::{DateTime, Utc};
+{{end}}{{if .HasUUID}}use uuid::Uuid;
+{{end}}
+{{range .Types}}#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct {{.Name}} {
+{{range .Properties}}    pub {{.Name}}: {{.OptionalType}},
+{{end}}}
+
+impl {{.Name}} {
+    pub fn schema_name() -> &'static str { "{{.Name}}" }
+}
+
+{{end}}

package/cdh/generators/scala/MANIFEST.toml

@@ -0,0 +1,20 @@
+[plugin]
+name = "scala"
+display_name = "Scala"
+file_extension = ".scala"
+mime_type = "text/x-scala"
+default_outdir = "scala"
+output_filename_template = "{name}.scala"
+package_name_default = "types"
+
+[features]
+enums = true
+allOf = true
+oneOf = true
+anyOf = true
+nullable = true
+format_hints = ["date-time", "uuid"]
+
+[imports]
+date-time = "import java.time.Instant"
+uuid = "import java.util.UUID"

package/cdh/generators/scala/template.scala.tmpl

@@ -0,0 +1,13 @@
+// Auto-generated from {{.SourceFile}}
+package {{.PackageName}}
+
+import java.time.Instant
+import java.util.UUID
+import io.circe.{Codec, Decoder, Encoder}
+import io.circe.generic.semiauto._
+
+{{range .Types}}
+case class {{.Name}}(
+{{range .Properties}}  {{.Name}}: {{if .IsNullable}}Option[String]{{else}}String{{end}},
+{{end}})
+{{end}}

package/cdh/generators/scheme/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for scheme
+[plugin]
+name = "scheme"
+display_name = "Scheme"
+file_extension = ".scm"
+mime_type = "text/x-scheme"
+default_outdir = "scheme"
+output_filename_template = "{name}}.scm"
+package_name_default = "types"
+
+[features]
+enums = false
+nullable = true
+format_hints = ["date-time", "uuid"]

package/cdh/generators/scheme/template.scm.tmpl

@@ -0,0 +1,16 @@
+;; Auto-generated from {{.SourceFile}}
+(define-module (types)
+  #:export ({{range .Types}}make-{{.Name}} {{end}}))
+
+{{range .Types}}
+(define-record-type {{.Name}}
+  ({{.Name}} {{range .Properties}}{{.Name}} {{end}})
+  {{.Name}}?
+{{range .Properties}}  ({{.Name}}-{{.Name}} {{.Name}}) {{end}})
+
+(define ({{.Name}}->alist x)
+  (list {{range .Properties}}(cons '{{.JsonName}}' ({{.Name}}-{{.Name}} x)) {{end}}))
+
+(define (alist->{{.Name}} alst)
+  ({{.Name}} {{range .Properties}}(cond ((assoc '{{.JsonName}} alst) => cdr) (else #f)) {{end}}))
+{{end}}

package/cdh/generators/solidity/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for solidity
+[plugin]
+name = "solidity"
+display_name = "Solidity"
+file_extension = ".sol"
+mime_type = "text/x-solidity"
+default_outdir = "solidity"
+output_filename_template = "{name}}.sol"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = false
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/solidity/template.sol.tmpl

@@ -0,0 +1,24 @@
+// Auto-generated from {{.SourceFile}}
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+{{range .Types}}
+struct {{.Name}} {
+{{range .Properties}}    {{.Type}} {{.Name}};
+{{end}}}
+{{end}}
+
+library Types {
+{{range .Types}}    function toStruct({{.Name}} memory self) internal pure returns ({{.Name}} memory) {
+        return self;
+    }
+
+    function toJson({{.Name}} memory self) internal pure returns (bytes memory) {
+        return abi.encode(self);
+    }
+
+    function fromJson(bytes memory data) internal pure returns ({{.Name}} memory) {
+        return abi.decode(data, ({{.Name}}));
+    }
+{{end}}
+}

package/cdh/generators/swift/MANIFEST.toml

@@ -0,0 +1,18 @@
+[plugin]
+name = "swift"
+display_name = "Swift"
+file_extension = ".swift"
+mime_type = "text/x-swift"
+default_outdir = "swift"
+output_filename_template = "{name}.swift"
+package_name_default = "Types"
+
+[features]
+enums = true
+allOf = true
+oneOf = true
+anyOf = true
+nullable = true
+readOnly = true
+writeOnly = true
+format_hints = ["date-time", "uuid", "email", "uri", "double"]

package/cdh/generators/swift/template.swift.tmpl

@@ -0,0 +1,10 @@
+// Auto-generated from {{.SourceFile}}
+import Foundation
+
+public protocol GeneratedType: Codable {}
+
+{{range .Types}}public struct {{.Name}}: GeneratedType {
+{{range .Properties}}    public let {{.Name}}: {{.NullableType}}
+{{end}}}
+
+{{end}}

package/cdh/generators/typescript/MANIFEST.toml

@@ -0,0 +1,18 @@
+[plugin]
+name = "typescript"
+display_name = "TypeScript"
+file_extension = ".ts"
+mime_type = "text/typescript"
+default_outdir = "."
+output_filename_template = "{name}.ts"
+package_name_default = "types"
+
+[features]
+enums = true
+allOf = true
+oneOf = true
+anyOf = true
+nullable = true
+readOnly = true
+writeOnly = true
+format_hints = ["date-time", "uuid", "email", "uri", "double"]

package/cdh/generators/typescript/template.ts.tmpl

@@ -0,0 +1,7 @@
+// Auto-generated from {{.SourceFile}}
+{{range .Types}}{{if .Description}}/** {{.Description}} */
+{{end}}export interface {{.Name}} {
+{{range .Properties}}  {{.JsonName}}{{if .IsNullable}}?{{end}}: {{.Type}};
+{{end}}}
+
+{{end}}

package/cdh/generators/version.py

@@ -0,0 +1,214 @@
+"""SemVer 2.0 parsing, comparison, and dependency resolution for aidlc plugins.
+
+Usage::
+
+    from cdh.generators.version import SemVer, resolve_dependencies
+    v1 = SemVer.from_string("1.2.3")
+    v2 = SemVer.from_string("2.0.0-alpha.1")
+    print(v1 < v2)  # True
+
+    deps = [{"name": "kotlin", "version": ">=1.0.0"}, {"name": "jvm", "version": "^2.0.0"}]
+    resolved = resolve_dependencies(deps, available={"kotlin": SemVer("1.5.0"), "jvm": SemVer("2.1.0")})
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Iterable
+
+__all__ = ["SemVer", "VersionSpec", "resolve_dependencies", "parse_version_spec"]
+
+
+@dataclass(frozen=True, order=True)
+class SemVer:
+    """Semantic version 2.0.0."""
+
+    major: int
+    minor: int
+    patch: int
+    pre: tuple[str, ...] = ()
+    build: tuple[str, ...] = ()
+
+    _RE = re.compile(
+        r"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)"
+        r"(?:-(?P<pre>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"
+        r"(?:\+(?P<build>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?$"
+    )
+
+    @classmethod
+    def from_string(cls, s: str) -> "SemVer":
+        m = cls._RE.match(s.strip())
+        if not m:
+            raise ValueError(f"Invalid semver: {s!r}")
+        pre = tuple(m["pre"].split(".")) if m["pre"] else ()
+        build = tuple(m["build"].split(".")) if m["build"] else ()
+        return cls(
+            major=int(m["major"]),
+            minor=int(m["minor"]),
+            patch=int(m["patch"]),
+            pre=pre,
+            build=build,
+        )
+
+    def __str__(self) -> str:
+        base = f"{self.major}.{self.minor}.{self.patch}"
+        if self.pre:
+            base += "-" + ".".join(self.pre)
+        if self.build:
+            base += "+" + ".".join(self.build)
+        return base
+
+    def satisfies(self, spec: "VersionSpec") -> bool:
+        return spec.matches(self)
+
+
+@dataclass(frozen=True)
+class VersionSpec:
+    """A version constraint like ^1.0.0, >=2.0.0, <3.0.0."""
+
+    op: str
+    version: SemVer
+
+    _OPS = {"==", "!=", ">=", "<=", ">", "<", "~>", "^", "="}
+
+    @classmethod
+    def parse(cls, s: str) -> "VersionSpec":
+        s = s.strip()
+        if s.startswith((">=", "<=", "==", "!=", ">", "<", "~>", "^")):
+            op = s[:2] if s.startswith((">=", "<=", "==", "!=", "~>", "^")) else s[:1]
+            ver_str = s[len(op):]
+        elif s.startswith("="):
+            op, ver_str = "==", s[1:]
+        else:
+            raise ValueError(f"Cannot parse version spec: {s!r}")
+        return cls(op=op, version=SemVer.from_string(ver_str.strip()))
+
+    def matches(self, v: SemVer) -> bool:
+        base = self.version
+        if self.op == "==":
+            return v == base
+        if self.op == "!=":
+            return v != base
+        if self.op == ">":
+            return v > base
+        if self.op == ">=":
+            return v >= base
+        if self.op == "<":
+            return v < base
+        if self.op == "<=":
+            return v <= base
+        if self.op == "^":
+            return v.major == base.major and (v.minor > base.minor or (v.minor == base.minor and v.patch >= base.patch))
+        if self.op == "~>":
+            return v.major == base.major and v.minor == base.minor and v.patch >= base.patch
+        if self.op == "=":
+            return v == base
+        raise ValueError(f"Unknown op: {self.op!r}")
+
+
+def parse_version_spec(constraint: str) -> VersionSpec:
+    """Parse a single version constraint string."""
+    return VersionSpec.parse(constraint)
+
+
+def resolve_dependencies(
+    deps: Iterable[dict[str, str]],
+    available: dict[str, SemVer],
+) -> dict[str, SemVer]:
+    """Resolve plugin dependencies.
+
+    Args:
+        deps: Iterable of {"name": str, "version": str} constraints
+        available: Map of plugin name -> installed SemVer
+
+    Returns:
+        Dict of plugin name -> resolved SemVer that satisfies constraints
+
+    Raises:
+        ValueError: If a dependency cannot be satisfied
+    """
+    resolved: dict[str, SemVer] = {}
+    for dep in deps:
+        name = dep.get("name") or dep.get("plugin")
+        constraint_str = dep.get("version") or dep.get("spec") or ">=0.0.0"
+        if not name:
+            continue
+
+        if name in resolved:
+            continue
+
+        if name not in available:
+            raise ValueError(f"Dependency {name} {constraint_str} not available")
+
+        spec = parse_version_spec(constraint_str)
+        candidate = available[name]
+
+        if not spec.matches(candidate):
+            raise ValueError(
+                f"Plugin {name}@{candidate} does not satisfy {spec.op}{spec.version} "
+                f"(available: {name}@{candidate})"
+            )
+
+        resolved[name] = candidate
+
+    return resolved
+
+
+class PluginRegistry:
+    """Plugin registry with version tracking and dependency resolution."""
+
+    def __init__(self):
+        self._plugins: dict[str, dict[str, SemVer | list[dict[str, str]]]] = {}
+
+    def add_plugin(
+        self,
+        name: str,
+        version: SemVer,
+        dependencies: list[dict[str, str]] | None = None,
+    ) -> None:
+        self._plugins[name] = {
+            "version": version,
+            "dependencies": dependencies or [],
+        }
+
+    def get_version(self, name: str) -> SemVer | None:
+        entry = self._plugins.get(name)
+        return entry["version"] if entry else None
+
+    def get_dependencies(self, name: str) -> list[dict[str, str]]:
+        entry = self._plugins.get(name)
+        return entry["dependencies"] if entry else []
+
+    def resolve_all(self) -> dict[str, SemVer]:
+        """Resolve all plugins and their transitive dependencies."""
+        resolved: dict[str, SemVer] = {}
+        to_resolve: list[tuple[str, list[dict[str, str]]]] = [
+            (name, deps) for name, info in self._plugins.items()
+            for deps in [info["dependencies"]]
+        ]
+
+        while to_resolve:
+            name, deps = to_resolve.pop(0)
+            if name in resolved:
+                continue
+            version = self.get_version(name)
+            if version is None:
+                raise ValueError(f"Plugin {name} not found in registry")
+            resolved[name] = version
+            for dep in deps:
+                dep_name = dep.get("name") or dep.get("plugin")
+                if dep_name:
+                    dep_deps = self.get_dependencies(dep_name)
+                    to_resolve.append((dep_name, dep_deps))
+
+        return resolved
+
+    def check_conflicts(self, selected: dict[str, SemVer]) -> list[str]:
+        """Check for version conflicts in selected plugins."""
+        conflicts: list[str] = []
+        for name, version in selected.items():
+            current = self.get_version(name)
+            if current and current != version:
+                conflicts.append(f"{name}: tried to set {version} but registry has {current}")
+        return conflicts

package/cdh/generators/zig/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for zig
+[plugin]
+name = "zig"
+display_name = "Zig"
+file_extension = ".zig"
+mime_type = "text/x-zig"
+default_outdir = "zig"
+output_filename_template = "{name}}.zig"
+package_name_default = "types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/zig/template.zig.tmpl

@@ -0,0 +1,20 @@
+// Auto-generated from {{.SourceFile}}
+const std = @import("std");
+const json = std.json;
+
+{{range .Types}}
+pub const {{.Name}} = struct {
+{{range .Properties}}    {{.Name}}: {{if .IsNullable}}?[]const u8{{else}}[]const u8{{end}},
+{{end}}};
+
+pub fn {{.Name}}_from_json(allocator: std.mem.Allocator, json_str: []const u8) !{{.Name}} {
+    const parsed = try json.parseFromSlice({{.Name}}, allocator, json_str);
+    return parsed.value;
+}
+
+pub fn {{.Name}}_to_json(allocator: std.mem.Allocator, obj: {{.Name}}) ![]u8 {
+    var buf = std.ArrayList(u8).init(allocator);
+    try json.stringify(allocator, obj, buf.writer());
+    return buf.toOwnedSlice();
+}
+{{end}}