mirror of
https://github.com/morluto/rea.git
synced 2026-10-26 17:35:11 +00:00
feat(environment): serve writes by what their recordings show (#6897)
* fix(environment): keep read-only POSTs out of the write list A POST that repeats the latest read of its path, tunnels only read operations, names a lookup in its path's last meaningful word, or renews a session no longer counts as a state write: it is replayed, does not cut initial windows, and does not end observation searches. A tool stays a write when a related read line changes across one of its calls. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): take an entity an unplanned write made when a read first shows it A successful item read of an entity the gate's copy never held, after a write no built plan models, puts the entity into the copy instead of failing the read, so later writes to it are checked as usual. An entity a modelled write touched is never taken back. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): plan a create into the type its returned id is read under A POST whose path names no state type becomes a create into the type whose item read first names an id its response returned, when the id is new to the state; serving creates in that read's collection. A successful POST that returned an id a type's reads only show after it also ends that type's initial window, so entities a capture created stay out of the initial state. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): end a type's initial reads at the write its reads disagree across When a type's reads disagree across a write under another root, the type's initial window now ends at the earliest write within that change and the state is extracted again, instead of leaving every view of the type replayed. The cut composes with the creation cut; the earlier wins. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): replay request lines that show entities in another form A read line that shows the same entities in another form, by an extra query parameter that adds or drops members, or conflicts with a base line on a shared entity, is a variant: it leaves the view's checks and the entity observations, the view names it with the query keys that pick it out, and a call matching those keys replays its recording. A filter role whose name matches no field needs two agreeing values. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): specify and record the state-target changes Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): keep a read-only POST a write when its evidence is incomplete Body-level container operations are skipped like query ones, a lookup is named only by the path's last literal segment and never alongside a write word, a tool with a redirected or unanswered call is not reclassified, and the mutation veto is resolved over all candidates at once so another read-only call cannot explain a read change. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): answer a field selection only when the state shows it exactly Serving tests a field selection before any variant key: a projection value a replayed read gave, or one no checked line gave other than `*`, replays. A list sets aside a line asking for some fields only before the identity proof, and a dropped variant's membership change no longer rewrites the type. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): hold adopted entities and linked creates to what the recording shows An adopted entity is charged against the view's budget like a created one. A linked create holds only for its exemplar's path arguments: serving refuses others and the gate counts such a call as unmodelled. A response's identity-named id links at any length, but a short one only to a type read before the call. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the review fixes' measurements Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): release a discarded planning pass before planning again A rewrite cut clears the first pass, so the budget rewinds to a checkpoint taken after the write cutoffs and created ids before the state is extracted again. Rewrite spans are charged and appended without spreading them into an argument list. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): link no create whose id an earlier read showed, and read only whole batches A linked create is rejected when an earlier list of its type or read of its collection showed the returned id. Body ids are walked without spreading children into an argument list. An RPC call reads only when every operations entry names an operation of its own. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): let the gate skip exactly the reads serving replays Serving's replay decision moves to the domain as replayReason, and the write gate uses it: a read serving replays can neither approve nor veto a write, and a read of every field beside a replayed selection is checked. A selection read missing a required field is still skipped, since part of an entity can neither confirm nor check it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the second review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): read writes, links and creation cuts only from evidence that rules out other causes - A read-only POST repeats only a read that finished before it began; the veto compares the latest read finished before a call with the first begun after it, and counts a recorded absence on one side as a change. `modify` and `replace` are write words. - A redirected or unanswered write lets a later item read adopt the entity it may have made. - A creation cut counts a read still running when the POST began as after it, and a list read shows its listed entities' own ids, not those they nest. - A linked create's item read must come before any other tool's write. - Line shapes are charged to the budget as they are built. - A `fields=*` list line is whole, not a field selection. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the third review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): tie linked creates to their returned ids and order state by the lines left - A linked create is observed only in a read of an id its response returned, envelopes included, and serving takes its recorded path values in either spelling. - A list read shows a suffix-named identity (`projectId`) distinct across its entities. - A read-only POST compares the read that finished last before it began. - An entity's first sighting comes from the lines left after variant lines are dropped. - The pairwise variant pass stops at a work limit, leaving every line checked. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the fourth review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): keep foreign keys, stale reads and double decoding out of write evidence - A list read counts a suffix-named field as its entities' ids only when no id-named field identifies them, so an `ownerId` beside `id` cuts no window. - A read-only POST is compared with the read that finished last among those no other write follows, so a consuming call stays a write. - A linked create's source path values compare as spelled on both sides, so no spelling is decoded twice. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the fifth review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): compare linked sources by position, decode path fields once and bound read and variant scans - A linked create's source values compare segment by segment, so a template naming two parameters alike cannot accept a changed first one. - Serving fills a linked create's path fields with its arguments decoded once, as the gate learned them. - The read-only check reads each related line's records once per call, between the nearest other writes. - Member signatures are JSON arrays, so a name holding the separator still conflicts; the variant work limit counts line pairs as well as entities. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the sixth review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): replay late and variant-only items, fill linked path fields from the exemplar and charge membership spans - An item line first recorded after the initial window that names a new shaping parameter and shows other members is a replayed variant, like an initial one. - An item only a replayed line showed, which the state never started with, answers with its own recording; one the state held and lost stays missing. - A linked create fills its path fields from its exemplar's path decoded once, whichever accepted spelling the call sends. - Each membership change span is charged against the budget before it is kept. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the seventh review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): blame a failed read on the writes whose fields it disagrees on A failed item read with no interfering unmodelled write contradicts its creates and deletes, and an update only when a field the update wrote or its response showed differs. A create is contradicted when a later read embeds it elsewhere and the state does not. A create member is fixed to its recorded value when a constant it would have to change derives from it: its text inside a constant, a referenced entity's name, or an instant beside a sent date, matched by related field names. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): explain unsent update changes and nested clocks by what the recording shows An update's unsent change can be a modified-by stamp beside a created-by counterpart, a value derived from the one sent member stored nowhere (accepted only while the target holds the recorded before-value), or a sent clock the call left in its own second. Objects whose clocks all moved with the request are nested clocks, opaque tokens of a type's own length are generated, and an enveloped body is learned as its one object. A write takes only its recorded query, an echoed reference to a nested object and a state word paired with other fields stay at their recorded values, and a slug is tried before a token. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): order collections by whole lines and sort only arrays a read-back proves sorted A collection's initial order comes from the first list line that shows every entity its type's sightings do and applies no order. A view renders a string-array field sorted only after a counted read-back shows the written values in an order that neither the written order nor existing-values-first explains, and never once a read showed it unsorted. Sort and direction parameters share one vocabulary and are never learned as inert, and a create placed by disagreeing sorts or a random id falls back to last. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(environment): serve bulk writes at a collection and target item actions A DELETE, PUT or PATCH at a collection, or a POST at its delete path, whose body names held entities by id is applied to each named entity, and serving refuses it unless every id is held. A POST to an entity's action path that answers nothing or the entity is an update of it; it is served only when a recorded call found each scalar it sets already at that value. Served bulk bodies advertise their items, and compare probes pass them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): decide late item lines against the lines left, charge replay keys and bisect rewrite cuts - Item lines first recorded after the initial reads are decided once variants are dropped, against the lines left: a new shaping parameter showing other members, or a selection of some fields leaving members out, replays. - Each replay key is charged against the budget before it is kept. - A rewrite span's earliest write is found by bisection over the writes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the eighth review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): set aside response members a path mints anew on every read A top-level UUID or clock that differs on every repeat of one path's successful reads, with no write between, is left out of that path's item, list and document comparisons and named in the view's per_response_members. Serving keeps the recorded value. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): count only reads finished before a linked create began as showing its id held A list still running when the call began may show what the call made, as the creation cut already decides, so it no longer refuses the link. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): count a list total nested in a paging object An item total in a top-level object beside the list, such as pageInfo.totalRows, is a counter on the same evidence as a top-level one: it must equal the number listed, and one that differs marks the line partial. Serving and the gate render it from the state through its JSON pointer and leave the object's other members as recorded. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): take a created entity's nested clocks from its read-back After a create's generated values pass, its stored nested clocks take the instants the first later read of the entity shows, as an update's already do, so a create whose response and read spell the clock differently is confirmed. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): import the compare tool definition as a type Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): describe the new write rules and trim repeated parsing The environment and capture docs describe sorted arrays, per-response members, nested counters, item actions, bulk writes, the new write rules and refusals, and their known limits. `_order` is a direction only. Sorted-array retries and the per-response scan parse only the reads they need, and identifier words come from one helper. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): confirm no update whose clocks or fields the evidence cannot show it writing An unsent clock an update left in the second it ran keeps the update unconfirmed until another call shows the clock stamped. A field the state lacks that the read and the update's response both show is the update's change, so without a rule for it the read confirms nothing. A modified-by name stamp brings its id sibling along, and created entities are indexed by id when a failed read is checked for embeds. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): show pinned query and body values in the served catalog and apply bulk writes atomically A pinned query parameter is required with its recorded value as the only choice, and a call that leaves it out takes that value. A fixed body member shows its recorded value, and an enveloped body its wrapping, in the schema, the description and the refusal. Bulk writes go through the same query pin and update or remove their entities at once. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): specify and record the write-rule changes Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): keep served creates' items missing, check same-type earlier reads, and bound late lines and read-only stretches - An item only a replayed line showed replays only while no served create has added to its type, so a created and deleted item stays missing. - A linked create's earlier item-read veto checks only reads of the candidate's type or collection that show the item, so another type's id does not hide it. - An item read answered with JSON null shows no id to a creation cut. - Late lines' member names are charged before they are kept. - The read-only check precomputes nearest writes and passes once over each write-free stretch per path, skipping lines whose reads all agree. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the ninth review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): link creates past empty item reads, sweep repeated reads once and keep only returned ids for creation cuts - A linked create passes over a later item read naming its id whose body shows no item, such as JSON null, and links the next one. - Read-only repeated reads are found in one sweep: each path's reads wait by end time until a call's start passes them, and a write clears them. - A creation cut keeps, and charges, only the shown ids some creation returned. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the tenth review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): take bulk ids literally, check each recorded call's query once, and keep learned sorts open to contrary reads Bulk writes take body ids as written, refuse a call naming one entity twice, size updates from the replacements installed, generate each entity's values from that entity, and delete only with the members their exemplar sent besides the ids. Comparison translates bulk body ids with the target collection's mapping. Update rules echo a creation clock sent back unchanged, require every held clock, and refuse a nested clock once any recorded call kept its object. A recorded call sent with another query than its exemplar's, including item actions, documents and deletes, neither confirms nor teaches its plan, and only successful calls with that query relax a create's guards. A counted read listing a learned array unsorted drops the sort from its view, sort evidence comes only from the entities the read covers, and a top-level counter whose name starts with a slash is named by its escaped pointer. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the review fixes' checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * perf(environment): compare variant lines through shared entities and parse each compared body once The variant pass indexes a tool's lines by the entities they show and compares only lines that share one, charging the index to the budget while it is held; the pairwise work limit still decides when a tool keeps every line checked. Read-only decisions keep each response body's canonical digest, taken once while its parse is charged, across calls and veto passes. The creation cut no longer parses reads at or after the write that ends the initial reads, and reads the ids a body shows inside its lease. Adoption looks up a read's target only after an unplanned write before it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the eleventh review round's checks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * perf(environment): list a type's collections only when the path's own holds no id, and parse variant base lines once The write gate's item target lists the type's held collections, and the removed targets', only when the path's own collection holds none of its ids, so a served item view's reads no longer walk every entity of the type. The variant pass parses the base lines' queries once for all the variants they key, and not at all when it found none. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the twelfth review round's checks and the sweep's cost Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): record the 50-capture sweep's wall, CPU and peak memory Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): remove duplicate schema after main integration * fix(environment): honor recorded bulk identity kinds * fix(environment): retain scoped evidence and honor write defaults * test(environment): keep SDK regressions independently scoped * docs(environment): record scoped write verification and measured costs * fix(environment): serve bulk writes whose response lists each entity they wrote A bulk call answering an array with one element per entity its body names, in the body's order, is classified by its elements, so the existing renderer serves it from the entities each call writes. Responses listing entities out of order, with differing members or id spellings, wrapped elements or an envelope still refuse. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(environment): measure the 50 captures at the scoped-envelope head Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(environment): classify bulk responses and release verifier transforms * fix(environment): classify and verify complete bulk responses * fix(javascript): retain capture context along covered mutation paths * test(environment): verify bulk responses through the real MCP SDK * test(environment): separate bulk response proof regressions * fix(environment): preserve request absence and generated value relationships * fix(environment): verify complete nested clocks on creates * fix(javascript): erase inline type imports before binding values * fix(environment): share complete generated value verification * fix(verifiers): load the Windows source graph only when needed * fix(environment): validate write responses before stored clock restamps --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com> Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com> Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
This commit is contained in:
91 files changed
+9988
-750
No files matched your search
@@ -660,17 +660,21 @@ repeated reads of one full request line whose list membership changes across a
|
||||
write, including transitions to or from an empty list, or whose entity fields
|
||||
are added or removed. A type whose reads still disagree keeps every tool a
|
||||
recorded view with reason `fields-differ`. Different query strings remain distinct request lines. Sparse responses do not erase the last observation of a field supplied by another request line. Entities are ordered
|
||||
by type, collection and first sighting; that order is a list's state order.
|
||||
by type and collection, and within a collection as the first line that lists
|
||||
every entity any initial read shows in it and names no sort, direction or
|
||||
random parameter (`random`, `rand`, `shuffle`, `seed`) lists them; a collection
|
||||
without such a line keeps its entities' earliest sightings. That order is a
|
||||
list's state order.
|
||||
Every entity cites its `record_ordinals`.
|
||||
|
||||
`views` lists one plan per read tool in tool order:
|
||||
|
||||
| Shape | Plan |
|
||||
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `item` | The entity object at `pointer` (the root, one member, or `/0` or `/<member>/0`), the ordered `fields` the view shows and the `required_fields` every recording had, and `envelope_ordinal`: the recording whose response, with the entity replaced, every item response shares |
|
||||
| `list` | The array at `pointer`, its `fields`, `membership` (`all`: every entity of the collection in state order, when each recording listed exactly that, had no query or only paging parameters (`limit`, `offset`, `page`, `per_page`, `perpage`, `page_size`, `pagesize`, `size`, `start`, `_start`, `_end`), no item-total member (`total`, `count`, `totalCount`, `item_count`, `totalcount`, `itemcount`, `numberOfElements`, but not `total_pages` or `per_page`; a number or a string of digits) differing from the number listed, and no `has_more`, `next` or next-page token member set; `recorded`: the entities each recording listed, except on the lines `all_record_ordinals` names, which each meet those conditions on their own and list every entity), and `counters` that equal the number listed |
|
||||
| `document` | The latest initial value of a list tool whose responses hold no identified list, when its initial reads share one request line; held in `documents` with that `path`, whether or not the capture writes it, unless its value changed across any recorded write between those reads (`fields-differ`) |
|
||||
| `recorded` | A `reason` the tool replays its recordings instead |
|
||||
| Shape | Plan |
|
||||
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `item` | The entity object at `pointer` (the root, one member, or `/0` or `/<member>/0`), the ordered `fields` the view shows and the `required_fields` every recording had, and `envelope_ordinal`: the recording whose response, with the entity replaced, every item response shares, leaving out the `per_response_members` each response there mints: a top-level UUID or clock that differed on every repeat of every concrete path the view answers, with no write between, and never stayed the same on a repeat elsewhere; list views name theirs too |
|
||||
| `list` | The array at `pointer`, its `fields`, `membership` (`all`: every entity of the collection in state order, when each recording listed exactly that, had no query or only paging parameters (`limit`, `offset`, `page`, `per_page`, `perpage`, `page_size`, `pagesize`, `size`, `start`, `_start`, `_end`), no item-total member (`total`, `count`, `totalCount`, `item_count`, `totalcount`, `itemcount`, `numberOfElements`, but not `total_pages` or `per_page`; a number or a string of digits; top-level, or in a top-level object beside the list such as `pageInfo.totalRows`) differing from the number listed, and no `has_more`, `next` or next-page token member set; `recorded`: the entities each recording listed, except on the lines `all_record_ordinals` names, which each meet those conditions on their own and list every entity), and `counters` that equal the number listed |
|
||||
| `document` | The latest initial value of a list tool whose responses hold no identified list, when its initial reads share one request line; held in `documents` with that `path`, whether or not the capture writes it, unless its value changed across any recorded write between those reads (`fields-differ`); its `per_response_members` are the members of the value each response on that path mints |
|
||||
| `recorded` | A `reason` the tool replays its recordings instead |
|
||||
|
||||
An item or list plan is kept only when it reproduces the latest initial
|
||||
recording of each request line from the state, comparing JSON values without
|
||||
@@ -700,29 +704,34 @@ collection, what each query parameter does, and names the result in `query`.
|
||||
Each such line is explained by the first combination of roles that lists
|
||||
exactly what it recorded from the collection's initial entities:
|
||||
|
||||
| Role | Parameter | Effect |
|
||||
| ----------- | ------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `filter` | any, on a `field` every listed item holds the value in | entities whose field equals the value as text, or whose array field holds it directly or as an object's `id`, `slug` or `name` |
|
||||
| `search` | `q`, `query`, `search`, `searchTerm`, `term`, `keyword`(s) | entities with one of `fields` containing the value, ignoring case; the fields are those it matched in the listed items, URLs only where nothing else matched |
|
||||
| `sort` | `order`, `orderBy`, `ordering`, `sort`, `sortBy` (and `_by` spellings) | ordered by the field the value names (`name`, `-name`, `name:desc`, `name-ASC`): numbers by value, text ignoring case, null last ascending, ties in state order |
|
||||
| `direction` | `dir`, `direction`, `order`, `orderDirection`, `sortDir`, `sortOrder` with `asc` or `desc` | the sort's direction |
|
||||
| `limit` | `limit`, `per_page`, `perPage`, `page_size`, `size`, `count`, `take`, `itemsPerPage` | page size; zero or a negative value lists every match |
|
||||
| `offset` | `offset`, `start`, `_start`, `skip` | matches skipped before the page |
|
||||
| `page` | `page` | page number, counted from `first` (1 or 0, whichever explains the line) |
|
||||
| `inert` | any | changes nothing for its recorded `values`; other values are not computed |
|
||||
| Role | Parameter | Effect |
|
||||
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `filter` | any other, on a `field` every listed item holds the value in; one not named like the field (`shelf`, or `shelf_id`, for `shelf`) stands only when lines giving it two different values agree on it | entities whose field equals the value as text, or whose array field holds it directly or as an object's `id`, `slug` or `name` |
|
||||
| `search` | `q`, `query`, `search`, `searchTerm`, `term`, `keyword`(s) | entities with one of `fields` containing the value, ignoring case; the fields are those it matched in the listed items, URLs only where nothing else matched; a term that matched no field leaves the parameter inert until another line's term does |
|
||||
| `sort` | a name asking for an order in any common spelling: `sort`, `_sort`, `sort[]`, `sort[0][field]`, `sorters[...]`, `sortBy`, `sort-column`, `sortKey`, `order`, `orderBy`, `ordering` | ordered by the field the value names (`name`, `-name`, `name:desc`, `name-ASC`): numbers by value, text ignoring case, null last ascending, ties in state order |
|
||||
| `direction` | a direction name (`dir`, `direction`, `sortDir`, `sortOrder`, `sortDirection`, `order_direction`, json-server's `_order`, and `order`) given `asc`, `desc`, `ascending` or `descending`; given anything else, `order` is a `sort` and the others are ordinary parameters | the sort's direction |
|
||||
| `limit` | `limit`, `per_page`, `perPage`, `page_size`, `size`, `count`, `take`, `itemsPerPage` | page size; zero or a negative value lists every match |
|
||||
| `offset` | `offset`, `start`, `_start`, `skip` | matches skipped before the page |
|
||||
| `page` | `page` | page number, counted from `first` (1 or 0, whichever explains the line) |
|
||||
| `inert` | any that names no order or direction; never a true `reverse`, or a paging value that is not a safe integer | changes nothing for its recorded `values`; other values are not computed |
|
||||
|
||||
Lines that disagree on a parameter's role drop it, inert values gather and
|
||||
search fields unite. `query.record_ordinals` are the lines the merged roles
|
||||
No two parameters of one call take the same `sort`, `direction` or paging role,
|
||||
and a line with more than 12 query parameters is left unexplained. Lines that
|
||||
disagree on a parameter's role drop it, inert values gather and search fields
|
||||
unite. `query.record_ordinals` are the lines the merged roles
|
||||
reproduce, envelope and fields included, and `query.totals` the envelope
|
||||
members that count every match before paging on each of them (a
|
||||
`number`-of-items member counts the page). The roles are inferences from the
|
||||
members that count every match before paging on each of them, top-level or one
|
||||
level down in a paging object (`/pageInfo/totalRows`); a `number`-of-items
|
||||
member counts the page. The roles are inferences from the
|
||||
recorded lines; a line they do not reproduce keeps its recorded members.
|
||||
|
||||
`writes` lists one plan per tool whose request may change state, in tool
|
||||
order. Its `effect` is `create` for a `POST` to a type's
|
||||
`collection_template`, `update` for a `PUT`, `PATCH` or `POST` to that template
|
||||
plus one trailing parameter, `delete` for a `DELETE` to it, `document` for a
|
||||
`PUT`, `PATCH` or `POST` to a document's path, and otherwise `none` with reason
|
||||
plus one trailing parameter, or to that item path plus one action segment,
|
||||
`delete` for a `DELETE` to it, `document` for a `PUT`, `PATCH` or `POST` to a
|
||||
document's path, an `update` or `delete` of each entity a write at the
|
||||
collection names by id in its body, and otherwise `none` with reason
|
||||
`no-state-target`. A plan is built from the tool's first successful call: its
|
||||
request body must be a usable JSON object (as response bodies are usable), and
|
||||
the written entity must show in that call's response or in a later read before
|
||||
@@ -731,14 +740,22 @@ explains it: generated `identity` (a sequence, UUID or token, by the recorded
|
||||
value's shape), `echo` of a body member, `copy` of a body string of 8 or more
|
||||
characters, a `path` value, a `slug` of a body member, a `clock` value within 10
|
||||
minutes of the request in its recorded format, a `sequence` one past the
|
||||
largest value of its collection or type, a `unique` UUID, or a `template` around
|
||||
a generated value; other fields keep the observed value. An update's members
|
||||
largest value of its collection or type, a `unique` UUID or opaque token, a
|
||||
`nested-clock` object whose clocks the request stamped, or a `template` around
|
||||
a generated value; other fields keep the observed value. A body that wraps one
|
||||
object in a one-element array is that object, wrapped so on every call
|
||||
(`body.envelope`). An update's members
|
||||
echo when stored as sent; a member stored differently is accepted only with its
|
||||
recorded value (`body.fixed`) and stores the value the call that showed it
|
||||
recorded (the `value` of its `constant` rule), and a field it changed without
|
||||
sending must be a clock, an increment or a slug, or the plan is
|
||||
`unexplained-change`; an increment or slug must hold for every call of the
|
||||
tool. Every member the first call sent is required, except by `PATCH` and
|
||||
sending must be a clock, a nested clock, an increment, a slug, a fresh `unique`
|
||||
value, a `stamp` of the acting user, a value `derived` from the one member it
|
||||
stores nowhere, or for an item action a `set` of a scalar to the value it
|
||||
showed, or the plan is `unexplained-change`; an increment, slug, stamp, derived
|
||||
value or set must hold for every call of the tool, and an action is served
|
||||
only once a call found what it sets already set. A write is served only
|
||||
with the query its first call sent, which serving applies to a call that
|
||||
leaves a parameter out and the catalog advertises as required. Every member the first call sent is required, except by `PATCH` and
|
||||
`POST` updates.
|
||||
|
||||
A read on a line `query` answers is checked against the query evaluated over
|
||||
|
||||
Reference in new issue
Block a user