zero-server 0.0.1__py3-none-any.whl

zero_server/server/server_schema.py

@@ -0,0 +1,165 @@
+"""The Postgres types behind each column of the Zero schema, and the check that they agree.
+
+Ported from rocicorp/mono `packages/zero-server/src/schema.ts` and `packages/zero-types/src/server-schema.ts`
+at zero/v1.10.0 (905d08516ba0caaf314cd28e93a5a47e8acdd482). Apache-2.0, Copyright Rocicorp.
+"""
+
+from dataclasses import dataclass
+
+from zero_server.schema import Schema
+from zero_server.server.pg_types import zql_value_type
+from zero_server.server.transaction import DBTransaction
+from zero_server.shared.asserts import check
+
+
+@dataclass(frozen=True)
+class ServerColumnSchema:
+    type: str
+    is_enum: bool
+    is_array: bool
+
+
+type ServerTableSchema = dict[str, ServerColumnSchema]
+type ServerSchema = dict[str, ServerTableSchema]
+
+# Reads pg_catalog rather than information_schema, as upstream does, for the same columns.
+_QUERY = """
+      SELECT
+          n.nspname::text AS schema,
+          cl.relname::text AS table,
+          a.attname::text AS column,
+          CASE
+              WHEN ut.typelem <> 0 AND ut.typlen = -1 THEN 'ARRAY'
+              WHEN nut.nspname = 'pg_catalog' THEN pg_catalog.format_type(ut.oid, NULL)
+              ELSE 'USER-DEFINED'
+          END::text AS "dataType",
+          CASE
+              WHEN tm.typmod = -1 THEN NULL
+              WHEN ut.oid IN ('pg_catalog.bpchar'::regtype, 'pg_catalog.varchar'::regtype) THEN tm.typmod - 4
+              WHEN ut.oid IN ('pg_catalog.bit'::regtype, 'pg_catalog.varbit'::regtype) THEN tm.typmod
+          END AS length,
+          CASE ut.oid
+              WHEN 'pg_catalog.int2'::regtype THEN 16
+              WHEN 'pg_catalog.int4'::regtype THEN 32
+              WHEN 'pg_catalog.int8'::regtype THEN 64
+              WHEN 'pg_catalog.float4'::regtype THEN 24
+              WHEN 'pg_catalog.float8'::regtype THEN 53
+              WHEN 'pg_catalog.numeric'::regtype THEN
+                CASE WHEN tm.typmod = -1 THEN NULL ELSE ((tm.typmod - 4) >> 16) & 65535 END
+          END AS precision,
+          CASE
+              WHEN ut.oid IN ('pg_catalog.int2'::regtype, 'pg_catalog.int4'::regtype, 'pg_catalog.int8'::regtype)
+                THEN 0
+              WHEN ut.oid = 'pg_catalog.numeric'::regtype AND tm.typmod <> -1 THEN (tm.typmod - 4) & 65535
+          END AS scale,
+          ut.typtype::text AS typtype,
+          ut.typname::text AS typename,
+          CASE WHEN ut.typelem <> 0 THEN et.typtype::text ELSE NULL END AS "elemTyptype",
+          CASE WHEN ut.typelem <> 0 THEN et.typname::text ELSE NULL END AS "elemTypname"
+      FROM
+          pg_catalog.pg_attribute a
+      JOIN pg_catalog.pg_class cl ON cl.oid = a.attrelid
+      JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace
+      JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+      JOIN pg_catalog.pg_type ut ON ut.oid = CASE WHEN t.typtype = 'd' THEN t.typbasetype ELSE t.oid END
+      JOIN pg_catalog.pg_namespace nut ON nut.oid = ut.typnamespace
+      LEFT JOIN pg_catalog.pg_type et ON et.oid = ut.typelem
+      CROSS JOIN LATERAL
+          (SELECT CASE WHEN t.typtype = 'd' THEN t.typtypmod ELSE a.atttypmod END AS typmod) tm
+      WHERE
+          a.attnum > 0
+          AND NOT a.attisdropped
+          AND cl.relkind IN ('r', 'v', 'f', 'p')
+          AND NOT pg_catalog.pg_is_other_temp_schema(n.oid)
+          AND (pg_catalog.pg_has_role(cl.relowner, 'USAGE')
+               OR pg_catalog.has_column_privilege(cl.oid, a.attnum, 'SELECT, INSERT, UPDATE, REFERENCES'))
+          AND (n.nspname, cl.relname) IN ({pairs})
+"""
+
+_ENUM = "e"
+
+
+def _schema_and_table(name: str, server_name: str | None) -> tuple[str, str]:
+    if server_name and "." in server_name:
+        schema, table = server_name.split(".", 1)
+        return schema, table
+    return "public", server_name or name
+
+
+async def get_server_schema(tx: DBTransaction[object], schema: Schema) -> ServerSchema:
+    pairs = [_schema_and_table(t.name, t.server_name) for t in schema.tables.values()]
+    if not pairs:
+        return {}
+    placeholders = ",".join(f"(${2 * i + 1}::text, ${2 * i + 2}::text)" for i in range(len(pairs)))
+    rows = await tx.query(_QUERY.format(pairs=placeholders), [part for pair in pairs for part in pair])
+
+    server_schema: ServerSchema = {}
+    for row in rows:
+        table_name = row["table"] if row["schema"] == "public" else f"{row['schema']}.{row['table']}"
+        table = server_schema.setdefault(table_name, {})
+        is_array = row["elemTyptype"] is not None
+        is_enum = (row["elemTyptype"] if row["elemTyptype"] is not None else row["typtype"]) == _ENUM
+        type_ = row["dataType"].lower()
+        if is_array:
+            check(
+                row["elemTypname"],
+                f'Array column "{row["column"]}" in table "{table_name}" is missing element type name',
+            )
+            type_ = row["elemTypname"]
+        elif is_enum or (type_ == "user-defined" and zql_value_type(row["typename"], False, False) is not None):
+            type_ = row["typename"]
+        if type_ in ("bpchar", "character", "character varying", "varchar") and row["length"]:
+            type_ = f"{type_}({row['length']})"
+        if type_ in ("numeric", "decimal") and row["precision"] is not None and row["scale"] is not None:
+            type_ = f"{type_}({row['precision']}, {row['scale']})"
+        table[row["column"]] = ServerColumnSchema(type=type_, is_enum=is_enum, is_array=is_array)
+
+    errors = check_schemas_are_compatible(schema, server_schema)
+    check(not errors, _incompatible_message(errors))
+    return server_schema
+
+
+def check_schemas_are_compatible(schema: Schema, server_schema: ServerSchema) -> list[str]:
+    """One message per table, column or type in `schema` that the database does not match."""
+    errors: list[str] = []
+    for table in schema.tables.values():
+        server_table_name = table.server_name or table.name
+        server_table = server_schema.get(server_table_name)
+        if server_table is None:
+            errors.append(
+                f'Table "{server_table_name}" is defined in your zero schema but does not exist in the database.'
+            )
+            continue
+        for column_name, column in table.columns.items():
+            server_column_name = column.server_name or column_name
+            server_column = server_table.get(server_column_name)
+            if server_column is None:
+                errors.append(
+                    f'Column "{server_column_name}" in table "{server_table_name}" is defined in your zero schema '
+                    "but does not exist in the database."
+                )
+                continue
+            required = zql_value_type(server_column.type, server_column.is_enum, server_column.is_array)
+            if required != column.type:
+                reason = (
+                    f"{server_column.type} is currently unsupported in Zero. Please file a bug at "
+                    "https://bugs.rocicorp.dev/"
+                    if required is None
+                    else f"{server_column.type} should be mapped to {required} in Zero not {column.type}."
+                )
+                errors.append(
+                    f'Type mismatch for column "{server_column_name}" in table "{server_table_name}": {reason}'
+                )
+    return errors
+
+
+def _incompatible_message(errors: list[str]) -> str:
+    return "\n".join(
+        [
+            "Schema incompatibility detected between your zero schema definition and the database:",
+            "",
+            *(f"  - {e}" for e in errors),
+            "",
+            "Please update your schema definition to match the database or migrate your database to match the schema.",
+        ]
+    )

zero_server/server/transaction.py

@@ -0,0 +1,70 @@
+"""The transaction a server mutator receives.
+
+Ported from rocicorp/mono `packages/zero-server/src/custom.ts` (`TransactionImpl`) and
+`packages/zql/src/mutate/custom.ts` at zero/v1.10.0 (905d08516ba0caaf314cd28e93a5a47e8acdd482).
+Apache-2.0, Copyright Rocicorp.
+"""
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Literal, Protocol, overload
+
+if TYPE_CHECKING:
+    from zero_server.query.builder import OneQuery, Query
+    from zero_server.schema import Schema
+    from zero_server.server.crud import Mutate
+    from zero_server.server.server_schema import ServerSchema
+
+type Row = dict[str, Any]
+
+
+class DBTransaction[W](Protocol):
+    """One open database transaction. `query` takes SQL with `$1`-style placeholders, as upstream's does."""
+
+    @property
+    def wrapped_transaction(self) -> W: ...
+
+    async def query(self, sql: str, params: Sequence[Any] = ()) -> list[Row]: ...
+
+
+class ServerTransaction[W]:
+    location: Literal["server"] = "server"
+    reason: Literal["authoritative"] = "authoritative"
+
+    def __init__(
+        self,
+        db_transaction: DBTransaction[W],
+        client_id: str,
+        mutation_id: int,
+        schema: "Schema | None" = None,
+        server_schema: "ServerSchema | None" = None,
+    ) -> None:
+        self.db_transaction = db_transaction
+        self.client_id = client_id
+        self.mutation_id = mutation_id
+        self._schema = schema
+        self._server_schema = server_schema
+
+    def _schemas(self, what: str) -> "tuple[Schema, ServerSchema]":
+        if self._schema is None or self._server_schema is None:
+            raise RuntimeError(f"{what} needs a schema: pass one to the database")
+        return self._schema, self._server_schema
+
+    @property
+    def mutate(self) -> "Mutate":
+        """CRUD on the schema's tables, in client names."""
+        from zero_server.server.crud import Mutate
+
+        schema, server_schema = self._schemas("tx.mutate")
+        return Mutate(schema, self.db_transaction, server_schema)
+
+    @overload
+    async def run[R](self, query: "OneQuery[R, Any]") -> R | None: ...
+    @overload
+    async def run[R](self, query: "Query[R, Any]") -> list[R]: ...
+    async def run(self, query: "Query[Any, Any]") -> Any:
+        """Run a ZQL query inside this transaction, against Postgres: a list of rows, or for a `one()`
+        query the row or `None`. Relationships come back nested under each row, under their names."""
+        from zero_server.server.pg_query_executor import execute_postgres_query
+
+        schema, server_schema = self._schemas("tx.run")
+        return await execute_postgres_query(self.db_transaction, query.ast, query.format, schema, server_schema)

zero_server/server/zql_database.py

@@ -0,0 +1,129 @@
+"""A transaction provider over any Postgres driver, with `tx.mutate` and `tx.run` for mutators.
+
+Ported from rocicorp/mono `packages/zero-server/src/zql-database.ts` at zero/v1.10.0
+(905d08516ba0caaf314cd28e93a5a47e8acdd482). Apache-2.0, Copyright Rocicorp.
+
+A driver plugs in as a `DBConnection`: something that opens a transaction and hands back a
+`DBTransaction` whose `query` takes `$1`-style placeholders. `zero_server.server.adapters` has one per
+supported driver.
+"""
+
+from collections.abc import Awaitable, Callable
+from typing import Any, Protocol, overload
+
+from zero_server.protocol.mutation import CleanupResultsArg, CleanupResultsBulkArg, MutationResponse
+from zero_server.query.builder import OneQuery, Query
+from zero_server.schema import Schema
+from zero_server.server.process_mutations import TransactionProviderHooks, TransactionProviderInput
+from zero_server.server.server_schema import ServerSchema, get_server_schema
+from zero_server.server.transaction import DBTransaction, ServerTransaction
+from zero_server.shared.js import js_stringify
+from zero_server.z2s.sql import ident
+
+
+class PostgresError(Exception):
+    """A statement Postgres refused, carrying its primary message.
+
+    Named as the postgres.js adapter names its errors upstream, so the error a client sees for a refused
+    statement is the same whichever server ran it.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message
+
+
+class DBConnection[W](Protocol):
+    """Opens one transaction, runs `fn` in it, and commits when `fn` returns or rolls back when it raises."""
+
+    async def transaction[R](self, fn: Callable[[DBTransaction[W]], Awaitable[R]]) -> R: ...
+
+
+class _Hooks:
+    def __init__(self, tx: DBTransaction[Any], transaction_input: TransactionProviderInput) -> None:
+        self._tx = tx
+        self._input = transaction_input
+        self._schema = ident(transaction_input.upstream_schema)
+
+    async def update_client_mutation_id(self) -> int:
+        rows = await self._tx.query(
+            f"""INSERT INTO {self._schema}.clients
+                    as current ("clientGroupID", "clientID", "lastMutationID")
+                VALUES ($1, $2, $3)
+                ON CONFLICT ("clientGroupID", "clientID")
+                DO UPDATE SET "lastMutationID" = current."lastMutationID" + 1
+                RETURNING "lastMutationID\"""",
+            (self._input.client_group_id, self._input.client_id, 1),
+        )
+        return int(rows[0]["lastMutationID"])
+
+    async def write_mutation_result(self, result: MutationResponse) -> None:
+        await self._tx.query(
+            f"""INSERT INTO {self._schema}.mutations
+                    ("clientGroupID", "clientID", "mutationID", "result")
+                VALUES ($1, $2, $3, $4::text::json)""",
+            (
+                self._input.client_group_id,
+                result.id.client_id,
+                result.id.id,
+                js_stringify(result.result.to_json()),
+            ),
+        )
+
+    async def delete_mutation_results(self, args: CleanupResultsArg) -> None:
+        if isinstance(args, CleanupResultsBulkArg):
+            await self._tx.query(
+                f"""DELETE FROM {self._schema}."mutations"
+                    WHERE "clientGroupID" = $1 AND "clientID" = ANY($2)""",
+                (args.client_group_id, list(args.client_ids)),
+            )
+        else:
+            await self._tx.query(
+                f"""DELETE FROM {self._schema}."mutations"
+                    WHERE "clientGroupID" = $1 AND "clientID" = $2 AND "mutationID" <= $3""",
+                (args.client_group_id, args.client_id, args.up_to_mutation_id),
+            )
+
+
+class ZQLDatabase[W]:
+    """Runs each mutation in one transaction of `connection`.
+
+    With a `schema`, mutators get `tx.mutate` and `tx.run`, and the first transaction checks the schema
+    against the database's columns.
+    """
+
+    def __init__(self, connection: DBConnection[W], schema: Schema | None = None) -> None:
+        self.connection = connection
+        self.schema = schema
+        self._server_schema: ServerSchema | None = None
+
+    async def transaction[R](
+        self,
+        callback: Callable[[ServerTransaction[W], TransactionProviderHooks], Awaitable[R]],
+        transaction_input: TransactionProviderInput | None = None,
+    ) -> R:
+        transaction_input = transaction_input or TransactionProviderInput(
+            upstream_schema="", client_group_id="", client_id="", mutation_id=0
+        )
+
+        async def run(tx: DBTransaction[W]) -> R:
+            if self.schema is not None and self._server_schema is None:
+                self._server_schema = await get_server_schema(tx, self.schema)
+            server_tx = ServerTransaction(
+                tx, transaction_input.client_id, int(transaction_input.mutation_id), self.schema, self._server_schema
+            )
+            return await callback(server_tx, _Hooks(tx, transaction_input))
+
+        return await self.connection.transaction(run)
+
+    @overload
+    async def run[R](self, query: OneQuery[R, Any]) -> R | None: ...
+    @overload
+    async def run[R](self, query: Query[R, Any]) -> list[R]: ...
+    async def run(self, query: Query[Any, Any]) -> Any:
+        """Run a ZQL query in a transaction of its own; see `ServerTransaction.run`."""
+
+        async def run(tx: ServerTransaction[W], _hooks: TransactionProviderHooks) -> Any:
+            return await tx.run(query)
+
+        return await self.transaction(run)

zero_server/shared/__init__.py

@@ -0,0 +1 @@
+"""Helpers shared across the port, from rocicorp/mono `packages/shared`."""

zero_server/shared/asserts.py

@@ -0,0 +1,19 @@
+"""Upstream's `assert`, which, unlike Python's, survives `python -O`.
+
+Ported from rocicorp/mono `packages/shared/src/asserts.ts` at zero/v1.10.0
+(905d08516ba0caaf314cd28e93a5a47e8acdd482). Apache-2.0, Copyright Rocicorp.
+"""
+
+from typing import Any, TypeGuard
+
+
+class AssertionFailedError(Exception):
+    """Upstream throws a plain `Error` here, so it reports no `name`."""
+
+    error_name = "Error"
+
+
+def check(condition: Any, message: str) -> TypeGuard[Any]:
+    if not condition:
+        raise AssertionFailedError(message)
+    return True

zero_server/shared/error.py

@@ -0,0 +1,97 @@
+"""Reading a message and JSON details off anything that was raised.
+
+Ported from rocicorp/mono `packages/shared/src/error.ts` at zero/v1.10.0
+(905d08516ba0caaf314cd28e93a5a47e8acdd482). Apache-2.0, Copyright Rocicorp.
+
+JavaScript's `Error` is Python's `Exception`: an error whose class is exactly `Exception` carries no
+`{name}` detail, the way a plain `Error` carries none upstream. A class can set `error_name` to the name
+its upstream counterpart reports, which is `"Error"` for the upstream classes that never set `this.name`.
+"""
+
+from typing import Any
+
+from zero_server.shared.js import js_stringify
+from zero_server.shared.json import JSONValue, is_json_value
+
+
+def get_error_message(error: object) -> str:
+    return _message(error, set())
+
+
+def _message(error: object, seen: set[int]) -> str:
+    if isinstance(error, str):
+        return error
+    if id(error) in seen:
+        return "Circular error reference detected while extracting the error message."
+    seen.add(id(error))
+
+    if isinstance(error, BaseException):
+        message = _exception_message(error)
+        if message:
+            return message
+        if error.__cause__ is not None:
+            return _message(error.__cause__, seen)
+
+    if isinstance(error, dict):
+        message = error.get("message")
+        if isinstance(message, str) and message:
+            return message
+
+    as_object = enumerable_properties(error) if isinstance(error, BaseException) else error
+    if is_json_value(as_object):
+        return f"Parsed message: {js_stringify(as_object)}"
+
+    return (
+        f"Unknown error of type {js_typeof(error)} was thrown and the message could not be determined. "
+        "See cause for details."
+    )
+
+
+def enumerable_properties(error: BaseException) -> dict[str, Any]:
+    """What `JSON.stringify` would see of an error: its own attributes, less those JavaScript hides.
+
+    `message` is never enumerable on a JavaScript error, and `ApplicationError` keeps its details in a
+    private field.
+    """
+    hidden = {"message", "details"} if type(error).__name__ == "ApplicationError" else {"message"}
+    return {k: v for k, v in vars(error).items() if not k.startswith("_") and k not in hidden}
+
+
+def js_typeof(value: object) -> str:
+    """`typeof` for what reaches the unknown-error path, which is never a JSON value."""
+    return "function" if callable(value) else "object"
+
+
+def _exception_message(error: BaseException) -> str:
+    message = getattr(error, "message", None)
+    if isinstance(message, str):
+        return message
+    if len(error.args) == 1 and isinstance(error.args[0], str):
+        return error.args[0]
+    return str(error)
+
+
+def get_error_details(error: object) -> JSONValue | None:
+    if isinstance(error, BaseException):
+        details: Any = getattr(error, "details", None)
+        if details is not None and is_json_value(details):
+            return details
+        name = error_name(error)
+        if name not in ("Exception", "Error"):
+            return {"name": name}
+        return None
+
+    if isinstance(error, dict) and "details" in error:
+        details = error["details"]
+        if is_json_value(details):
+            return details
+
+    if is_json_value(error):
+        return error  # ty: ignore[invalid-return-type]
+    return None
+
+
+def error_name(error: BaseException) -> str:
+    """The `name` upstream would report for this error."""
+    name = getattr(type(error), "error_name", None)
+    return name if isinstance(name, str) else type(error).__name__

zero_server/shared/js.py

@@ -0,0 +1,121 @@
+"""JavaScript's `String(value)`, for the places upstream compares stringified values."""
+
+import json
+from collections.abc import Callable
+from decimal import Decimal
+from functools import cmp_to_key
+
+
+def js_string(value: object) -> str:
+    match value:
+        case None:
+            return "null"
+        case bool():
+            return "true" if value else "false"
+        case int() | float():
+            return js_number(value)
+        case list() | tuple():
+            return ",".join("" if item is None else js_string(item) for item in value)
+        case dict():
+            return "[object Object]"
+        case _:
+            return str(value)
+
+
+def js_number(value: float) -> str:
+    """`Number.prototype.toString()`: the shortest round-trip digits, laid out by ECMA-262's rules."""
+    if value == 0:
+        return "0"
+    if value < 0:
+        return "-" + js_number(-value)
+    _sign, digit_tuple, exponent = Decimal(repr(float(value))).as_tuple()
+    assert isinstance(exponent, int)
+    digits = "".join(map(str, digit_tuple)).rstrip("0")
+    exponent += len(digit_tuple) - len(digits)
+    k = len(digits)
+    n = k + exponent
+    if k <= n <= 21:
+        return digits + "0" * (n - k)
+    if 0 < n <= 21:
+        return digits[:n] + "." + digits[n:]
+    if -6 < n <= 0:
+        return "0." + "0" * -n + digits
+    e = n - 1
+    exp = f"e{'+' if e >= 0 else '-'}{abs(e)}"
+    return digits + exp if k == 1 else digits[0] + "." + digits[1:] + exp
+
+
+def js_sort[T](items: list[T], compare: Callable[[T, T], int]) -> list[T]:
+    """`items.sort(compare)` as V8 runs it, returning a new list.
+
+    Upstream's `cmpCondition` is not a consistent comparator (a compound condition and a subquery each
+    sort before the other), so the result depends on the exact comparisons the sort makes. V8 sorts an
+    array shorter than 64 by finding the leading run and binary-inserting the rest, which this repeats
+    comparison for comparison. Longer arrays fall back to Python's sort, which is the same TimSort.
+    """
+    out = list(items)
+    n = len(out)
+    if n < 2:
+        return out
+    if n >= 64:
+        return sorted(out, key=cmp_to_key(compare))
+    run = 2
+    descending = compare(out[1], out[0]) < 0
+    while run < n:
+        order = compare(out[run], out[run - 1])
+        if (order < 0) != descending:
+            break
+        run += 1
+    if descending:
+        out[:run] = reversed(out[:run])
+    for start in range(run, n):
+        pivot = out[start]
+        left, right = 0, start
+        while left < right:
+            mid = left + ((right - left) >> 1)
+            if compare(pivot, out[mid]) < 0:
+                right = mid
+            else:
+                left = mid + 1
+        out[left + 1 : start + 1] = out[left:start]
+        out[left] = pivot
+    return out
+
+
+def js_truthy(value: object) -> bool:
+    """JavaScript's truthiness for a JSON value: an empty array or object is truthy there."""
+    if value is None or value is False or value == "":
+        return False
+    if isinstance(value, int | float) and not isinstance(value, bool):
+        return value == value and value != 0  # NaN is falsy
+    return True
+
+
+def js_stringify(value: object) -> str:
+    """`JSON.stringify(value)` for a JSON value: compact, numbers written as JavaScript writes them."""
+    match value:
+        case None:
+            return "null"
+        case bool():
+            return "true" if value else "false"
+        case int() | float():
+            return js_number(value)
+        case str():
+            return json.dumps(value, ensure_ascii=False)
+        case list() | tuple():
+            return "[" + ",".join(js_stringify(item) for item in value) + "]"
+        case dict():
+            members = (f"{json.dumps(k, ensure_ascii=False)}:{js_stringify(value[k])}" for k in js_keys(value))
+            return "{" + ",".join(members) + "}"
+        case _:
+            raise TypeError(f"not a JSON value: {type(value).__name__}")
+
+
+def _is_array_index(key: str) -> bool:
+    return key.isascii() and key.isdigit() and (key == "0" or key[0] != "0") and int(key) < 2**32 - 1
+
+
+def js_keys(obj: dict[str, object]) -> list[str]:
+    """`Object.keys(obj)`: array-index keys first in numeric order, then the rest as inserted."""
+    indexes = sorted((k for k in obj if _is_array_index(k)), key=int)
+    return indexes + [k for k in obj if not _is_array_index(k)]

zero_server/shared/json.py

@@ -0,0 +1,27 @@
+"""JSON values, as Zero's wire format allows them.
+
+Ported from rocicorp/mono `packages/shared/src/json.ts` at zero/v1.10.0
+(905d08516ba0caaf314cd28e93a5a47e8acdd482). Apache-2.0, Copyright Rocicorp.
+"""
+
+import math
+from typing import Any
+
+from pydantic import JsonValue
+
+type JSONValue = JsonValue
+
+
+def is_json_value(value: Any) -> bool:
+    """Whether `value` survives `JSON.stringify` unchanged."""
+    match value:
+        case None | bool() | int() | str():
+            return True
+        case float():
+            return math.isfinite(value)
+        case list() | tuple():
+            return all(is_json_value(item) for item in value)
+        case dict():
+            return all(isinstance(key, str) and is_json_value(item) for key, item in value.items())
+        case _:
+            return False