formkrafter 0.1.0__tar.gz

formkrafter-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/

formkrafter-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Streamline Pulse
+
+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.

formkrafter-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.5
+Name: formkrafter
+Version: 0.1.0
+Summary: FormKrafter for Python backends: validate form submissions exactly like @streamline-pulse/formkrafter-core does in the browser
+Project-URL: Homepage, https://github.com/streamline-pulse/formkrafter/tree/main/python#readme
+Project-URL: Repository, https://github.com/streamline-pulse/formkrafter
+Project-URL: Issues, https://github.com/streamline-pulse/formkrafter/issues
+Author: Streamline Pulse
+License-Expression: MIT
+License-File: LICENSE
+Keywords: form-builder,formkrafter,forms,json-schema,validation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.6; extra == 'pydantic'
+Provides-Extra: regex
+Requires-Dist: regex>=2024.4; extra == 'regex'
+Description-Content-Type: text/markdown
+
+# formkrafter (Python)
+
+FormKrafter for Python backends. The server validates a submission with the same spec the browser renders, and
+reaches the same verdict: same error keys (`items[0].hs_code`), same messages, same warnings as
+[`@streamline-pulse/formkrafter-core`](../packages/core).
+
+```bash
+pip install formkrafter            # no dependency
+pip install "formkrafter[pydantic]"  # Pydantic models for specs built in code
+```
+
+```python
+from formkrafter import validate_form_data
+
+result = validate_form_data(spec, payload, locale="fr")
+if not result.valid:
+    # {"items[0].declared_value": "Minimum 0", "origin": "Ce champ est obligatoire"}
+    return 422, result.errors
+```
+
+## What it does
+
+| Function | Core equivalent |
+|---|---|
+| `build_validation_schema(spec, locale)` | `buildValidationSchema`: the same Ajv schema, key for key |
+| `validate_form_data(spec, data, locale)` | `validateFormData`: empty strings and nulls count as missing, collections are validated row by row |
+| `lint_spec(spec)` | `lintSpec`: keyless inputs, validations without a dataType, duplicate keys, empty collections |
+| `register_validation_messages(locale, messages)` | `registerValidationMessages` |
+| `default_form_data`, `iterate_bricks`, `iterate_schema_bricks`, `resolve_localized_text` | same names in camelCase |
+
+`validate_form_data` returns a `ValidationResult`:
+
+- `valid`, `errors` (key → message) and `warnings`, as in the browser; `to_dict()` gives the core's shape;
+- `details` (key → `ErrorDetail(validator, message, value)`), so an API can return a stable code and let the
+  client word it: `{"items[0].declared_value": {"validator": "min", "value": 0, "message": "Minimum 0"}}`.
+
+Every function takes a plain dict or a `formkrafter.models.BrickSpec`.
+
+### Supported
+
+- **Validations:** `required`, `min`/`max`, `minLength`/`maxLength`, `pattern`, `minItems`/`maxItems`, `email`, `url`.
+- **Bricks:** panels, inputs, selects (multiple included), collections (data grids, nested at any depth), outputs.
+  On top of those, `date-range` must not end before it starts.
+- **Rules:** rules that only disable, prefill or require a field are accepted. They do not change the verdict,
+  in the browser either.
+
+The details that usually make a Python port drift are reproduced:
+
+- Ajv's `email` and `uri` formats, copied verbatim;
+- the browser's `RegExp`: `$` never matches before a trailing newline, and `\d` is ASCII;
+- `String(1e-7)` is `1e-7`;
+- the core compares lengths in code points;
+- a schema Ajv refuses to compile enforces no rule (with a warning).
+
+### Refused
+
+`validate_form_data` raises `SpecNotSupported` rather than half-validating a spec that needs:
+
+- **JavaScript custom validators** (`validator: "custom"`). They run in the browser's sandbox and are not executed
+  server-side: move the check to the server, or to a declarative validation.
+- **Rules that hide data-carrying fields.** A hidden field's errors are dropped in the browser. json-logic
+  evaluation is planned.
+- **The checks not ported yet:** identity numbers (`national-id`, `tax-id`, `iban`), `vehicle-plate`,
+  `company-registry`, `mrz`.
+
+`build_validation_schema` and `lint_spec` work on every spec. `assert_supported(spec)` checks up front, for
+instance in the tests that cover the specs a backend serves.
+
+## Parity with the core
+
+`tests/parity/cases.json` holds specs and data samples. The core compiles and validates them:
+
+```bash
+bun scripts/python-parity.ts      # from the repository root: rewrites tests/parity/expected.json
+uv run pytest                     # the port must reach the same schemas, lint issues and verdicts
+```
+
+CI regenerates the fixtures and fails when they are stale, so a change in the core shows up in the Python tests.
+`formkrafter.CORE_VERSION` names the core release a version follows.
+
+### In your own project
+
+`formkrafter.testing` checks your specs against the real core, through Node and your web app's installed
+`@streamline-pulse/formkrafter-core`:
+
+```python
+from formkrafter.testing import assert_matches_core
+
+def test_served_forms_match_the_browser():
+    assert_matches_core(SPEC, samples=[VALID, {}, {"items": []}], locales=["fr", "en"], node_project="../web")
+```
+
+`export_contract(spec, locales)` returns the spec with its schema per locale. Write it where your web tests read
+it to assert that `buildValidationSchema(spec, locale)` gives the same.

formkrafter-0.1.0/README.md

@@ -0,0 +1,94 @@
+# formkrafter (Python)
+
+FormKrafter for Python backends. The server validates a submission with the same spec the browser renders, and
+reaches the same verdict: same error keys (`items[0].hs_code`), same messages, same warnings as
+[`@streamline-pulse/formkrafter-core`](../packages/core).
+
+```bash
+pip install formkrafter            # no dependency
+pip install "formkrafter[pydantic]"  # Pydantic models for specs built in code
+```
+
+```python
+from formkrafter import validate_form_data
+
+result = validate_form_data(spec, payload, locale="fr")
+if not result.valid:
+    # {"items[0].declared_value": "Minimum 0", "origin": "Ce champ est obligatoire"}
+    return 422, result.errors
+```
+
+## What it does
+
+| Function | Core equivalent |
+|---|---|
+| `build_validation_schema(spec, locale)` | `buildValidationSchema`: the same Ajv schema, key for key |
+| `validate_form_data(spec, data, locale)` | `validateFormData`: empty strings and nulls count as missing, collections are validated row by row |
+| `lint_spec(spec)` | `lintSpec`: keyless inputs, validations without a dataType, duplicate keys, empty collections |
+| `register_validation_messages(locale, messages)` | `registerValidationMessages` |
+| `default_form_data`, `iterate_bricks`, `iterate_schema_bricks`, `resolve_localized_text` | same names in camelCase |
+
+`validate_form_data` returns a `ValidationResult`:
+
+- `valid`, `errors` (key → message) and `warnings`, as in the browser; `to_dict()` gives the core's shape;
+- `details` (key → `ErrorDetail(validator, message, value)`), so an API can return a stable code and let the
+  client word it: `{"items[0].declared_value": {"validator": "min", "value": 0, "message": "Minimum 0"}}`.
+
+Every function takes a plain dict or a `formkrafter.models.BrickSpec`.
+
+### Supported
+
+- **Validations:** `required`, `min`/`max`, `minLength`/`maxLength`, `pattern`, `minItems`/`maxItems`, `email`, `url`.
+- **Bricks:** panels, inputs, selects (multiple included), collections (data grids, nested at any depth), outputs.
+  On top of those, `date-range` must not end before it starts.
+- **Rules:** rules that only disable, prefill or require a field are accepted. They do not change the verdict,
+  in the browser either.
+
+The details that usually make a Python port drift are reproduced:
+
+- Ajv's `email` and `uri` formats, copied verbatim;
+- the browser's `RegExp`: `$` never matches before a trailing newline, and `\d` is ASCII;
+- `String(1e-7)` is `1e-7`;
+- the core compares lengths in code points;
+- a schema Ajv refuses to compile enforces no rule (with a warning).
+
+### Refused
+
+`validate_form_data` raises `SpecNotSupported` rather than half-validating a spec that needs:
+
+- **JavaScript custom validators** (`validator: "custom"`). They run in the browser's sandbox and are not executed
+  server-side: move the check to the server, or to a declarative validation.
+- **Rules that hide data-carrying fields.** A hidden field's errors are dropped in the browser. json-logic
+  evaluation is planned.
+- **The checks not ported yet:** identity numbers (`national-id`, `tax-id`, `iban`), `vehicle-plate`,
+  `company-registry`, `mrz`.
+
+`build_validation_schema` and `lint_spec` work on every spec. `assert_supported(spec)` checks up front, for
+instance in the tests that cover the specs a backend serves.
+
+## Parity with the core
+
+`tests/parity/cases.json` holds specs and data samples. The core compiles and validates them:
+
+```bash
+bun scripts/python-parity.ts      # from the repository root: rewrites tests/parity/expected.json
+uv run pytest                     # the port must reach the same schemas, lint issues and verdicts
+```
+
+CI regenerates the fixtures and fails when they are stale, so a change in the core shows up in the Python tests.
+`formkrafter.CORE_VERSION` names the core release a version follows.
+
+### In your own project
+
+`formkrafter.testing` checks your specs against the real core, through Node and your web app's installed
+`@streamline-pulse/formkrafter-core`:
+
+```python
+from formkrafter.testing import assert_matches_core
+
+def test_served_forms_match_the_browser():
+    assert_matches_core(SPEC, samples=[VALID, {}, {"items": []}], locales=["fr", "en"], node_project="../web")
+```
+
+`export_contract(spec, locales)` returns the spec with its schema per locale. Write it where your web tests read
+it to assert that `buildValidationSchema(spec, locale)` gives the same.

formkrafter-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "formkrafter"
+version = "0.1.0"
+description = "FormKrafter for Python backends: validate form submissions exactly like @streamline-pulse/formkrafter-core does in the browser"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Streamline Pulse" }]
+keywords = ["formkrafter", "forms", "form-builder", "json-schema", "validation"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+pydantic = ["pydantic>=2.6"]
+# Unicode property classes (\p{L}) in `pattern` validations, as the browser's RegExp `u` flag allows
+regex = ["regex>=2024.4"]
+
+[project.urls]
+Homepage = "https://github.com/streamline-pulse/formkrafter/tree/main/python#readme"
+Repository = "https://github.com/streamline-pulse/formkrafter"
+Issues = "https://github.com/streamline-pulse/formkrafter/issues"
+
+[dependency-groups]
+dev = ["pytest>=8", "pydantic>=2.6", "ruff>=0.6", "mypy>=1.11"]
+
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/formkrafter"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.mypy]
+strict = true
+files = ["src"]

formkrafter-0.1.0/src/formkrafter/__init__.py

@@ -0,0 +1,39 @@
+"""FormKrafter for Python backends: the spec compiled to the browser's validation schema, and submitted
+data validated with it — same error keys, same messages, same verdict as `@streamline-pulse/formkrafter-core`.
+"""
+
+from formkrafter.lint import SpecIssue, lint_spec, validation_warnings
+from formkrafter.messages import default_validation_message, register_validation_messages
+from formkrafter.spec import (
+    BrickSpec,
+    build_validation_schema,
+    default_form_data,
+    iterate_bricks,
+    iterate_schema_bricks,
+    resolve_localized_text,
+)
+from formkrafter.validate import ErrorDetail, SpecNotSupported, ValidationResult, assert_supported, validate_form_data
+
+__version__ = "0.1.0"
+# The core release whose behaviour this version reproduces (python/tests/parity/expected.json).
+CORE_VERSION = "0.33.0"
+
+__all__ = [
+    "CORE_VERSION",
+    "BrickSpec",
+    "ErrorDetail",
+    "SpecIssue",
+    "SpecNotSupported",
+    "ValidationResult",
+    "assert_supported",
+    "build_validation_schema",
+    "default_form_data",
+    "default_validation_message",
+    "iterate_bricks",
+    "iterate_schema_bricks",
+    "lint_spec",
+    "register_validation_messages",
+    "resolve_localized_text",
+    "validate_form_data",
+    "validation_warnings",
+]

formkrafter-0.1.0/src/formkrafter/_js.py

@@ -0,0 +1,150 @@
+"""JavaScript semantics the core relies on: `Number()`, `String()` of a number, Ajv's formats and `RegExp`.
+
+The core runs in a JavaScript engine and Ajv; the port reproduces the few places where Python would
+otherwise disagree (`String(1e-7)` is "1e-7", `$` never matches before a trailing newline, `\\d` is ASCII).
+"""
+
+from __future__ import annotations
+
+import math
+from decimal import Decimal
+from typing import Any
+
+try:  # `\p{L}` and other `u`-flag classes, when the optional `regex` module is installed
+    import regex as _re  # type: ignore[import-not-found, import-untyped, unused-ignore]
+except ImportError:  # pragma: no cover - exercised when regex is absent
+    import re as _re
+
+Number = int | float
+
+
+def to_number(value: Any) -> Number:
+    """`Number(value)`: "12" is 12, "" and null are 0, true is 1, anything unreadable is NaN."""
+    if isinstance(value, bool):
+        return int(value)
+    if value is None:
+        return 0
+    if isinstance(value, int | float):
+        return _tidy(float(value)) if isinstance(value, float) else value
+    if isinstance(value, str):
+        text = value.strip()
+        if not text:
+            return 0
+        lowered = text.lower()
+        for prefix, base in (("0x", 16), ("0o", 8), ("0b", 2)):
+            if lowered.startswith(prefix):
+                try:
+                    return int(text[2:], base)
+                except ValueError:
+                    return math.nan
+        if text in ("Infinity", "+Infinity"):
+            return math.inf
+        if text == "-Infinity":
+            return -math.inf
+        if "_" in text or lowered.lstrip("+-") in ("inf", "infinity", "nan"):
+            return math.nan
+        try:
+            return _tidy(float(text))
+        except ValueError:
+            return math.nan
+    if isinstance(value, list) and len(value) <= 1:
+        return to_number(value[0]) if value else 0
+    return math.nan
+
+
+def _tidy(n: float) -> Number:
+    """An integral float as an int (JSON writes 3, not 3.0), within the range JavaScript counts exactly."""
+    return int(n) if n.is_integer() and abs(n) < 2**53 else n
+
+
+def number_to_string(n: Number) -> str:
+    """`String(n)`: 1 → "1", 0.5 → "0.5", 1e-7 → "1e-7", 1e21 → "1e+21"."""
+    if isinstance(n, bool):
+        return "true" if n else "false"
+    if isinstance(n, int):
+        n_float = float(n)
+        if abs(n) < 10**21:
+            return str(n)
+        n = n_float
+    if math.isnan(n):
+        return "NaN"
+    if math.isinf(n):
+        return "Infinity" if n > 0 else "-Infinity"
+    if n == 0:
+        return "0"
+    digits = Decimal(repr(n))
+    if 1e-6 <= abs(n) < 1e21:
+        text = format(digits, "f")
+        return text.rstrip("0").rstrip(".") if "." in text else text
+    sign, coefficient, exponent = digits.normalize().as_tuple()
+    mantissa = "".join(map(str, coefficient))
+    exp = exponent + len(mantissa) - 1  # type: ignore[operator]
+    body = mantissa[0] + ("." + mantissa[1:] if len(mantissa) > 1 else "")
+    return f"{'-' if sign else ''}{body}e{'+' if exp >= 0 else '-'}{abs(exp)}"
+
+
+def to_string(value: Any) -> str:
+    """`String(value ?? "")`, as the default messages interpolate `{value}`."""
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int | float):
+        return number_to_string(value)
+    if isinstance(value, list):
+        return ",".join("" if v is None else to_string(v) for v in value)
+    if isinstance(value, dict):
+        return "[object Object]"
+    return str(value)
+
+
+def compile_pattern(pattern: str) -> Any:
+    """`new RegExp(pattern, "u")` as a Python pattern: `$` anchors the end only, named groups, ASCII `\\d` and `\\w`."""
+    out: list[str] = []
+    in_class = False
+    i = 0
+    while i < len(pattern):
+        c = pattern[i]
+        if c == "\\" and i + 1 < len(pattern):
+            escape = pattern[i + 1]
+            if in_class:
+                out.append(_CLASS_ESCAPES.get(escape, pattern[i : i + 2]))
+            else:
+                out.append(_ESCAPES.get(escape, pattern[i : i + 2]))
+            i += 2
+            continue
+        if in_class:
+            if c == "]":
+                in_class = False
+        elif c == "[":
+            in_class = True
+        elif c == "$":
+            c = r"\Z"
+        elif pattern.startswith("(?<", i) and not pattern.startswith(("(?<=", "(?<!"), i):
+            c, i = "(?P<", i + 2
+        out.append(c)
+        i += 1
+    return _re.compile("".join(out))
+
+
+# Under the `u` flag \d and \w are ASCII, while Python's are Unicode; \s stays Unicode in both.
+_ESCAPES = {"d": "[0-9]", "D": "[^0-9]", "w": "[A-Za-z0-9_]", "W": "[^A-Za-z0-9_]"}
+_CLASS_ESCAPES = {"d": "0-9", "w": "A-Za-z0-9_"}
+
+
+# ajv-formats 3, "full" mode, verbatim (the core registers them with `addFormats(ajv, ["email", "uri"])`).
+# They carry no `u` flag, so digits and case folding are ASCII.
+_EMAIL = _re.compile(
+    r"^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\Z",
+    _re.IGNORECASE | _re.ASCII,
+)
+_NOT_URI_FRAGMENT = _re.compile(r"/|:")
+_URI = _re.compile(
+    r"^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?\Z",
+    _re.IGNORECASE | _re.ASCII,
+)
+
+FORMATS = {
+    "email": lambda s: bool(_EMAIL.search(s)),
+    "uri": lambda s: bool(_NOT_URI_FRAGMENT.search(s)) and bool(_URI.search(s)),
+}

formkrafter-0.1.0/src/formkrafter/lint.py

@@ -0,0 +1,99 @@
+"""Spec checks — `utils/lint-spec.ts` in the core: what silently breaks validation, on the client and the server."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from formkrafter.spec import configs_of, iterate_bricks, truthy
+
+SpecIssueCode = Literal[
+    "validations-without-data-type",
+    "input-without-key",
+    "duplicate-key",
+    "collection-without-children",
+]
+
+
+@dataclass(frozen=True)
+class SpecIssue:
+    code: SpecIssueCode
+    path: str
+    message: str
+    key: str | None = field(default=None)
+
+    def to_dict(self) -> dict[str, Any]:
+        """The issue as the core returns it (no `key` when the brick has none)."""
+        out: dict[str, Any] = {"code": self.code, "path": self.path}
+        if self.key is not None:
+            out["key"] = self.key
+        out["message"] = self.message
+        return out
+
+
+def lint_spec(spec: Any) -> list[SpecIssue]:
+    """Issues of a spec: keyless inputs, validations without a dataType, duplicate keys, empty collections."""
+    issues: list[SpecIssue] = []
+    seen: dict[str, str] = {}
+
+    for brick, path in iterate_bricks(spec):
+        key: Any = configs_of(brick).get("key")
+        has_key = truthy(key)
+        brick_type = brick.get("type")
+        carries_data = brick_type in ("input", "collection")
+
+        if carries_data:
+            if not has_key:
+                issues.append(
+                    SpecIssue(
+                        "input-without-key",
+                        path,
+                        f'{brick_type} brick "{brick.get("id")}" has no configs.key — '
+                        "it carries no data and is skipped by validation",
+                    )
+                )
+            elif not truthy(brick.get("dataType")) or brick.get("dataType") == "void":
+                validations = brick.get("validations") or []
+                if validations:
+                    issues.append(
+                        SpecIssue(
+                            "validations-without-data-type",
+                            path,
+                            f'"{key}" declares {len(validations)} validation(s) but has no dataType — '
+                            "they are silently skipped, on the client and on the server",
+                            key,
+                        )
+                    )
+
+        if has_key and carries_data:
+            previous = seen.get(key)
+            if previous:
+                issues.append(
+                    SpecIssue(
+                        "duplicate-key",
+                        path,
+                        f'key "{key}" is used by two bricks ({previous} and {path}) — '
+                        "their values collide in the form data",
+                        key,
+                    )
+                )
+            else:
+                seen[key] = path
+
+        if brick_type == "collection" and not brick.get("children"):
+            issues.append(
+                SpecIssue(
+                    "collection-without-children",
+                    path,
+                    f'collection "{key if key is not None else brick.get("id")}" has no row template — '
+                    "it can never produce data",
+                    key,
+                )
+            )
+
+    return issues
+
+
+def validation_warnings(spec: Any) -> list[str]:
+    """The lint messages that `validate_form_data` returns as warnings."""
+    return [issue.message for issue in lint_spec(spec) if issue.code == "validations-without-data-type"]

formkrafter-0.1.0/src/formkrafter/messages.py

@@ -0,0 +1,68 @@
+"""Default validation messages, per locale — `validators/default-messages.ts` in the core."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from formkrafter._js import to_string
+
+_MESSAGES: dict[str, dict[str, str]] = {
+    "en": {
+        "required": "This field is required",
+        "minLength": "Must be at least {value} characters",
+        "maxLength": "Must be at most {value} characters",
+        "min": "Must be at least {value}",
+        "max": "Must be at most {value}",
+        "pattern": "Invalid format",
+        "minItems": "Select at least {value} item(s)",
+        "maxItems": "Select at most {value} item(s)",
+        "email": "Invalid email address",
+        "url": "Invalid URL",
+        "type": "Invalid value",
+        "custom": "Invalid value",
+        "identity": "Invalid identifier for this format",
+        "iban": "Invalid IBAN",
+        "dateRange": "The end before the start is not allowed",
+        "mrz": "Machine-readable zone unreadable or inconsistent",
+        "plate": "Invalid registration plate for this format",
+        "registry": "Invalid registration number for this format",
+    },
+    "fr": {
+        "required": "Ce champ est obligatoire",
+        "minLength": "Minimum {value} caractères",
+        "maxLength": "Maximum {value} caractères",
+        "min": "Minimum {value}",
+        "max": "Maximum {value}",
+        "pattern": "Format invalide",
+        "minItems": "Sélectionnez au moins {value} élément(s)",
+        "maxItems": "Sélectionnez au plus {value} élément(s)",
+        "email": "Adresse email invalide",
+        "url": "URL invalide",
+        "type": "Valeur invalide",
+        "custom": "Valeur invalide",
+        "identity": "Identifiant invalide pour ce format",
+        "iban": "IBAN invalide",
+        "dateRange": "La fin ne peut pas précéder le début",
+        "mrz": "Zone de lecture illisible ou incohérente",
+        "plate": "Immatriculation invalide pour ce format",
+        "registry": "Numéro d’immatriculation invalide pour ce format",
+    },
+}
+
+
+def register_validation_messages(locale: str, messages: Mapping[str, str]) -> None:
+    """Add or override the default messages of a locale (`registerValidationMessages`).
+
+    Register the same messages on the client, or the server and the browser word their errors differently.
+    """
+    _MESSAGES[locale] = {**_MESSAGES.get(locale, {}), **messages}
+
+
+def default_validation_message(validator: str, locale: str | None = None, value: Any = None) -> str:
+    """The default message of a validator, with `{value}` filled in; English when the locale has none."""
+    pack = _MESSAGES.get("en" if locale is None else locale, _MESSAGES["en"])
+    template = pack.get(validator)
+    if template is None:
+        template = _MESSAGES["en"].get(validator, "Invalid value")
+    return template.replace("{value}", to_string(value), 1)