@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/reference/http/router.js

@@ -0,0 +1,121 @@
+/** One request in, one answer out: the fixed routes in order, then the entity model's. */
+import { SAFE } from "../../spec/methods.js";
+import { assertParents, assertTenant } from "./access.js";
+import { authenticate } from "./auth/credentials.js";
+import { errorResponse, HttpError } from "./errors.js";
+import { inbox, notify, startJob } from "./handlers/actions.js";
+import { create } from "./handlers/create.js";
+import { createKey, listKeys, readKey, renameKey, revokeKey } from "./handlers/api-keys.js";
+import { deleteAccount, deleteSelf, login, logout, refresh, register, revokeToken, signups, token, } from "./handlers/auth.js";
+import { account, document, health, me, notices, overview } from "./handlers/fixed.js";
+import { totp } from "./handlers/totp.js";
+import { accept, invite, revoke } from "./handlers/grants.js";
+import { read, remove, update } from "./handlers/item.js";
+import { list } from "./handlers/list.js";
+import { cachedRead } from "./read-cache.js";
+import { search } from "./handlers/query-route.js";
+import { styles } from "./handlers/styles.js";
+import { matchRoute } from "./routes.js";
+import { advanceJobs, typedScope } from "./store-ops.js";
+/* In the order they are tried: an earlier route shadows a later one. */
+const FIXED = [
+    document,
+    token,
+    login,
+    refresh,
+    revokeToken,
+    createKey,
+    listKeys,
+    readKey,
+    renameKey,
+    revokeKey,
+    startJob,
+    notify,
+    inbox,
+    invite,
+    accept,
+    revoke,
+    health,
+    notices,
+    register,
+    signups,
+    logout,
+    deleteSelf,
+    deleteAccount,
+    overview,
+    me,
+    account,
+    totp,
+    styles,
+    search,
+];
+/** The answer to `request`; a refusal or failure is an answer too. */
+export async function handle(state, request) {
+    try {
+        return await route(state, request);
+    }
+    catch (error) {
+        return errorResponse(error, state.defects);
+    }
+}
+async function route(state, request) {
+    const { url } = request;
+    /* Mounted under a prefix, the API exists only there. */
+    if (state.basePath !== "") {
+        if (url.pathname !== state.basePath && !url.pathname.startsWith(`${state.basePath}/`)) {
+            throw new HttpError(404, "not_found", `no route for ${url.pathname}`);
+        }
+        url.pathname = url.pathname.slice(state.basePath.length) || "/";
+    }
+    for (const fixed of FIXED) {
+        const answer = await fixed(state, request);
+        if (answer !== undefined)
+            return answer;
+    }
+    return entityRoute(state, request);
+}
+async function entityRoute(state, request) {
+    const { method, url } = request;
+    const match = matchRoute(url.pathname, state.entities);
+    if (match === null)
+        throw new HttpError(404, "not_found", `no route for ${url.pathname}`);
+    const { entity } = match;
+    /* A record route takes a bearer JWT, or an API key holding the entity's read or write scope. */
+    const access = SAFE.has(method) ? "read" : "write";
+    const principal = authenticate(state, request, {
+        projectId: match.scope["project_id"],
+        scope: `${entity.name}:${access}`,
+    });
+    const scope = await typedScope(state, match.scope);
+    const itemId = match.itemId === null ? null : scope[entity.itemParam];
+    const call = { entity, principal, scope };
+    /* Item GET may be a delegated read — a tenant check would 403 a valid grant before the lookup
+     * can honor it. Collection GET and mutations stay tenant-bound. */
+    if (method !== "GET" || itemId === null) {
+        assertTenant(principal, scope["project_id"]);
+        await assertParents(state, call);
+    }
+    if (entity.name === state.job.name && method === "GET")
+        await advanceJobs(state);
+    if (itemId === null) {
+        if (method === "GET" && entity.unlisted === true) {
+            throw new HttpError(405, "method_not_allowed", `${entity.plural} cannot be listed`);
+        }
+        if (method === "GET")
+            return cachedRead(state, { request, who: principal.key }, () => list(state, request, call));
+        if (method === "POST")
+            return create(state, request, call);
+        throw new HttpError(404, "not_found", `method ${method} not supported here`);
+    }
+    return item(state, request, { ...call, itemId });
+}
+function item(state, request, call) {
+    if (request.method === "GET")
+        return cachedRead(state, { request, who: call.principal.key }, () => read(state, call));
+    if (request.method === state.updateMethod)
+        return update(state, request, call);
+    if (request.method === "DELETE")
+        return remove(state, call);
+    throw new HttpError(405, "method_not_allowed", `method ${request.method} not supported`);
+}
+//# sourceMappingURL=router.js.map

package/dist/api/reference/http/routes.d.ts

@@ -0,0 +1,9 @@
+/** Which entity route a path names, and the path parameters it carries. */
+import type { EntityDef } from "../model/types.ts";
+export interface Match {
+    entity: EntityDef;
+    scope: Record<string, string>;
+    itemId: string | null;
+}
+export declare function matchRoute(pathname: string, entities: readonly EntityDef[]): Match | null;
+//# sourceMappingURL=routes.d.ts.map

package/dist/api/reference/http/routes.js

@@ -0,0 +1,31 @@
+/** Which entity route a path names, and the path parameters it carries. */
+export function matchRoute(pathname, entities) {
+    const segments = pathname.split("/").filter(Boolean);
+    for (const entity of entities) {
+        for (const [template, isItem] of [
+            [entity.itemPath, true],
+            [entity.collectionPath, false],
+        ]) {
+            const scope = bind(template, segments);
+            if (scope !== null)
+                return { entity, itemId: isItem ? (scope[entity.itemParam] ?? null) : null, scope };
+        }
+    }
+    return null;
+}
+/* The parameters `template` takes from `segments`, or `null` when the path is not one of its. */
+function bind(template, segments) {
+    const parts = template.split("/").filter(Boolean);
+    if (parts.length !== segments.length)
+        return null;
+    const scope = {};
+    for (const [index, part] of parts.entries()) {
+        const value = segments[index];
+        if (part.startsWith("{"))
+            scope[part.slice(1, -1)] = decodeURIComponent(value);
+        else if (part !== value)
+            return null;
+    }
+    return scope;
+}
+//# sourceMappingURL=routes.js.map

package/dist/api/reference/http/server.d.ts

@@ -0,0 +1,10 @@
+/** The reference backend behind a socket: the in-process handler on a local port, for what needs a real URL. */
+import type { createServer, Server } from "node:http";
+import { type Reference, type StoreFactory } from "./reference.ts";
+import { type ReferenceOptions } from "./state.ts";
+export interface ReferenceServer extends Omit<Reference, "fetch"> {
+    server: Server;
+}
+/** One server, any store: the handler `createReference` runs, listening on 127.0.0.1. */
+export declare function createReferenceServer(options: ReferenceOptions, createStore: StoreFactory, create?: typeof createServer): Promise<ReferenceServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/api/reference/http/server.js

@@ -0,0 +1,25 @@
+/** The reference backend behind a socket: the in-process handler on a local port, for what needs a real URL. */
+import { listen } from "./node.js";
+import { closeStore, createdIds, referenceState, snapshot } from "./reference.js";
+import { handle } from "./router.js";
+import { PRINCIPALS } from "./state.js";
+/** One server, any store: the handler `createReference` runs, listening on 127.0.0.1. */
+export async function createReferenceServer(options, createStore, create) {
+    const state = await referenceState(options, createStore);
+    const listening = await listen((request) => handle(state, request), create);
+    return {
+        /* The store is closed once the socket is, whatever a persistent backend still holds. */
+        close: async () => {
+            await listening.close();
+            await closeStore(state);
+        },
+        createdIds: () => createdIds(state),
+        defects: state.defects,
+        issuedTotpSecrets: () => [...state.totpSecrets],
+        principals: PRINCIPALS,
+        server: listening.server,
+        snapshot: () => snapshot(state),
+        url: `${listening.origin}${state.basePath}`,
+    };
+}
+//# sourceMappingURL=server.js.map

package/dist/api/reference/http/state.d.ts

@@ -0,0 +1,102 @@
+/** Everything one reference server holds between requests. */
+import type { DefectSet } from "../defects/defect-set.ts";
+import type { Dialect } from "../dialect/types.ts";
+import type { EntityDef } from "../model/types.ts";
+import type { QueryConventions } from "../query/conventions.ts";
+import type { ReferenceShape } from "../shapes/types.ts";
+import type { Row, Store } from "../store-api.ts";
+import type { Account, AuthState } from "./auth/types.ts";
+import type { Ids } from "./ids.ts";
+import type { ReferenceResponse } from "./wire.ts";
+export type { Account, Principal } from "./auth/types.ts";
+/** Two tenants' admins, then the first tenant's member and viewer: each signs in by key, or by email and password. */
+export declare const PRINCIPALS: readonly Account[];
+export declare const TENANT_FIELD = "project_id";
+/** Path parameters, typed: an integer identifier is a number from the moment it is parsed. */
+export type Scope = Record<string, string | number>;
+/** A collection: an entity, under the path scope that names it. */
+export interface Collection {
+    entity: EntityDef;
+    scope: Scope;
+}
+/** A stored record, with the entity it is a record of. */
+export interface EntityRecord {
+    entity: EntityDef;
+    record: Row;
+}
+/** Where one record is kept: its entity and its identifier. */
+export interface RecordKey {
+    entity: EntityDef;
+    id: string | number;
+}
+export interface ReferenceOptions {
+    defects?: string[];
+    untagged?: boolean;
+    dialect?: string;
+    /** A correct API shape the API tester was not written against — by name, or spelled out. */
+    shape?: string | ReferenceShape;
+    /** Answer 429 with Retry-After once one identity fails 5 logins within a minute. */
+    throttleLogins?: boolean;
+    /** Milliseconds since the epoch, for token expiry and the login throttle. Default: the wall clock. */
+    clock?: () => number;
+}
+/** An invitation to a table: readable by the invitee once accepted, until revoked. */
+export interface Grant {
+    accepted: boolean;
+    entity: string;
+    grantId: string;
+    granteeKey: string;
+    resourceId: string;
+    token: string;
+}
+/** The signed-up caller's profile; a phone number only under the string guard. */
+export interface Profile {
+    first_name: string;
+    phone_number?: string;
+}
+export interface ReferenceState {
+    untagged: boolean;
+    defects: DefectSet;
+    shape: ReferenceShape;
+    dialect: Dialect;
+    entities: readonly EntityDef[];
+    table: EntityDef;
+    job: EntityDef;
+    conventions: QueryConventions;
+    basePath: string;
+    updateMethod: string;
+    store: Store;
+    /** The store as a listing sees it: under HIDDEN_FROM_CREATOR, hidden rows are not there. */
+    listingStore: Store;
+    ids: Ids;
+    /** When each started job began, to advance it on read. */
+    jobStartedAt: Map<string, number>;
+    /** Snapshot of a collection taken before a write, replayed while STALE_LIST is on. */
+    staleSnapshot: Map<string, Row[]>;
+    /** Entities whose first listing has already been refused, for RATE_LIMIT_STRICTER_THAN_DECLARED. */
+    throttled: Set<string>;
+    /** Idempotency-Key → the record the first request created, so a replay returns it. */
+    idempotent: Map<string, Row>;
+    /** Delivered notifications, per project. */
+    inboxes: Map<string, Array<{
+        id: string;
+        message: string;
+    }>>;
+    grants: Map<string, Grant>;
+    /** The caller's own profile, per principal key. */
+    profiles: Map<string, Profile>;
+    /** Every TOTP secret `auth.setup2fa` issued, under the totp-setup shape. */
+    totpSecrets: string[];
+    /** Accounts, issued and revoked tokens, API keys and failed logins. */
+    auth: AuthState;
+    /** Under `tableKey: "slug"`, each table's slug by its internal id: the identity a client knows. */
+    slugOf: Map<string, string>;
+    /** Under the cached-reads shape, each caller's cached read answers. */
+    readCache: Map<string, {
+        response: ReferenceResponse;
+        storedAt: number;
+    }>;
+    /** Milliseconds since the epoch: the read cache's clock. */
+    clock: () => number;
+}
+//# sourceMappingURL=state.d.ts.map

package/dist/api/reference/http/state.js

@@ -0,0 +1,22 @@
+/** Everything one reference server holds between requests. */
+/** Two tenants' admins, then the first tenant's member and viewer: each signs in by key, or by email and password. */
+export const PRINCIPALS = [
+    { email: "alpha@reference.test", key: "key_alpha", password: "alpha-password", projectId: "proj_alpha", rank: 2 },
+    { email: "beta@reference.test", key: "key_beta", password: "beta-password", projectId: "proj_beta", rank: 2 },
+    {
+        email: "alpha.member@reference.test",
+        key: "key_alpha_member",
+        password: "member-password",
+        projectId: "proj_alpha",
+        rank: 1,
+    },
+    {
+        email: "alpha.viewer@reference.test",
+        key: "key_alpha_viewer",
+        password: "viewer-password",
+        projectId: "proj_alpha",
+        rank: 0,
+    },
+];
+export const TENANT_FIELD = "project_id";
+//# sourceMappingURL=state.js.map

package/dist/api/reference/http/store-ops.d.ts

@@ -0,0 +1,47 @@
+/** What the server reads and writes on its own account: identities, uniqueness, derived counts, jobs. */
+import type { EntityDef } from "../model/types.ts";
+import type { Row } from "../store-api.ts";
+import { type EntityRecord, type RecordKey, type ReferenceState, type Scope } from "./state.ts";
+/** The path's parameters, each read as the type its entity declares. */
+export declare function typedScope(state: ReferenceState, raw: Record<string, string>): Promise<Scope>;
+/**
+ * The internal id of the table a path's `{table_id}` names. Under `tableKey: "slug"` that is the
+ * slug, looked up in the path's project — two projects may each hold one — and, under
+ * FOREIGN_PARENT_ACCEPTED, in any project when the path's has none. Elsewhere it is the id.
+ */
+export declare function tableByKey(state: ReferenceState, projectId: string, raw: string): Promise<string | number>;
+/** The live records of one parent scope — what uniqueness and derived counts range over. */
+export declare function liveRows(state: ReferenceState, entity: EntityDef, scope: Record<string, unknown>): Promise<Row[]>;
+/** Refuses a record that repeats a unique set of another live one; `exceptId` is the record being rewritten. */
+export declare function assertUnique(state: ReferenceState, written: EntityRecord, exceptId?: string): Promise<void>;
+/**
+ * Keeps a parent's derived count current after a child write.
+ *
+ * This is the behavior `x-invalidate` promises: a write here changes what a *different* route
+ * serves. Under the defect the promise is published and not kept, which is the common real
+ * failure — a denormalized counter or a cached projection that nobody refreshes.
+ */
+export declare function refreshParentCount(state: ReferenceState, entity: EntityDef, scope: Scope): Promise<void>;
+/**
+ * PATCH without a lock: read the row, yield, then write every column back — the ORM
+ * `save(entity)` pattern. Two concurrent patches to different fields, and the later write
+ * reinstates the earlier field's old value. The yield makes the window observable rather than
+ * dependent on scheduler luck; it runs only under the defect.
+ */
+export declare function readModifyWrite(state: ReferenceState, { entity, id }: RecordKey, patch: Row): Promise<Row | null>;
+/**
+ * Advances started jobs and writes the result back.
+ *
+ * Progress is persisted rather than computed per response, so a filter on `status` and the body it
+ * returns describe the same state. Applied before every job read.
+ */
+export declare function advanceJobs(state: ReferenceState): Promise<void>;
+/**
+ * Records that exist before the API tester arrives — what every real environment has.
+ *
+ * Names alternate case so binary and case-insensitive collations order them differently, some
+ * descriptions are null, and values repeat, so the data looks like a lived-in collection rather
+ * than a fixture. Written straight to the store: none of it is the API tester's to clean up.
+ */
+export declare function prepopulate(state: ReferenceState, perTenant: number): Promise<void>;
+//# sourceMappingURL=store-ops.d.ts.map

package/dist/api/reference/http/store-ops.js

@@ -0,0 +1,161 @@
+/** What the server reads and writes on its own account: identities, uniqueness, derived counts, jobs. */
+import { and } from "../query/tree.js";
+import { HttpError } from "./errors.js";
+import { tombstoned, withDefaults } from "./records.js";
+import { TENANT_FIELD } from "./state.js";
+import { pathId } from "./validation.js";
+/** The path's parameters, each read as the type its entity declares. */
+export async function typedScope(state, raw) {
+    const scope = {};
+    for (const [param, value] of Object.entries(raw))
+        scope[param] = pathId(state.entities, param, value);
+    if (state.shape.tableKey === "slug" && raw["table_id"] !== undefined) {
+        scope["table_id"] = await tableByKey(state, String(scope["project_id"] ?? ""), raw["table_id"]);
+    }
+    return scope;
+}
+/**
+ * The internal id of the table a path's `{table_id}` names. Under `tableKey: "slug"` that is the
+ * slug, looked up in the path's project — two projects may each hold one — and, under
+ * FOREIGN_PARENT_ACCEPTED, in any project when the path's has none. Elsewhere it is the id.
+ */
+export async function tableByKey(state, projectId, raw) {
+    const { table } = state;
+    if (state.shape.tableKey !== "slug")
+        return pathId(state.entities, table.itemParam, raw);
+    const named = await state.store.select(table, {
+        collation: "binary",
+        order: [],
+        shuffleTies: false,
+        where: { asText: false, field: "slug", kind: "cmp", nullsMatch: false, op: "eq", value: raw },
+    });
+    /* A live table before a deleted one: a slug is free again once its table is gone. */
+    const live = named.toSorted((a, b) => Number(tombstoned(table, a)) - Number(tombstoned(table, b)));
+    const found = live.find((row) => row[TENANT_FIELD] === projectId) ??
+        (state.defects.has("FOREIGN_PARENT_ACCEPTED") ? live[0] : undefined);
+    return found === undefined ? `${table.name}:missing:${raw}` : found[table.identity];
+}
+/** The live records of one parent scope — what uniqueness and derived counts range over. */
+export async function liveRows(state, entity, scope) {
+    const constraints = Object.entries(scope)
+        .filter(([name, value]) => value !== undefined && entity.fields.some((field) => field.name === name))
+        .map(([field, value]) => ({
+        asText: false,
+        field,
+        kind: "cmp",
+        nullsMatch: false,
+        op: "eq",
+        value: value,
+    }));
+    const soft = entity.softDeleteField;
+    const where = and(...constraints, soft === undefined ? null : { field: soft, kind: "isnull", negate: false });
+    return state.store.select(entity, { collation: "binary", order: [], shuffleTies: false, where });
+}
+/** Refuses a record that repeats a unique set of another live one; `exceptId` is the record being rewritten. */
+export async function assertUnique(state, written, exceptId) {
+    const { entity, record } = written;
+    if (state.defects.has("UNIQUE_NOT_ENFORCED"))
+        return;
+    /* A slug names a table within its project, so it is unique there; the document does not say so. */
+    const slugged = state.shape.tableKey === "slug" && entity.name === state.table.name;
+    const sets = [...(entity.unique ?? []), ...(slugged ? [["slug"]] : [])];
+    if (sets.length === 0)
+        return;
+    const scope = {};
+    for (const parent of entity.parents)
+        scope[parent] = record[parent];
+    scope[TENANT_FIELD] = record[TENANT_FIELD];
+    const others = (await liveRows(state, entity, scope)).filter((row) => exceptId === undefined || String(row[entity.identity]) !== exceptId);
+    const taken = sets.find((set) => others.some((row) => set.every((col) => JSON.stringify(row[col]) === JSON.stringify(record[col]))));
+    if (taken !== undefined)
+        throw new HttpError(409, "conflict", `unique constraint violated (${taken.join(", ")})`);
+}
+/**
+ * Keeps a parent's derived count current after a child write.
+ *
+ * This is the behavior `x-invalidate` promises: a write here changes what a *different* route
+ * serves. Under the defect the promise is published and not kept, which is the common real
+ * failure — a denormalized counter or a cached projection that nobody refreshes.
+ */
+export async function refreshParentCount(state, entity, scope) {
+    if (entity.name !== "row" || state.defects.has("PARENT_PROJECTION_STALE"))
+        return;
+    const tableId = scope["table_id"];
+    if (tableId === undefined)
+        return;
+    const total = (await liveRows(state, entity, { table_id: tableId })).length;
+    await state.store.update(state.table, tableId, { row_count: total });
+}
+/**
+ * PATCH without a lock: read the row, yield, then write every column back — the ORM
+ * `save(entity)` pattern. Two concurrent patches to different fields, and the later write
+ * reinstates the earlier field's old value. The yield makes the window observable rather than
+ * dependent on scheduler luck; it runs only under the defect.
+ */
+export async function readModifyWrite(state, { entity, id }, patch) {
+    const current = await state.store.byId(entity, id);
+    if (current === null)
+        return null;
+    await new Promise((resolve) => setTimeout(resolve, 15));
+    return state.store.update(entity, id, { ...current, ...patch });
+}
+/**
+ * Advances started jobs and writes the result back.
+ *
+ * Progress is persisted rather than computed per response, so a filter on `status` and the body it
+ * returns describe the same state. Applied before every job read.
+ */
+export async function advanceJobs(state) {
+    if (state.defects.has("ASYNC_NEVER_COMPLETES"))
+        return;
+    for (const [id, startedAt] of state.jobStartedAt) {
+        const ratio = Math.min((Date.now() - startedAt) / 60, 1);
+        const progress = Math.floor(ratio * 100);
+        const status = ratio >= 1 ? "complete" : progress > 0 ? "running" : "pending";
+        const current = await state.store.byId(state.job, id);
+        if (current === null) {
+            state.jobStartedAt.delete(id);
+            continue;
+        }
+        if (current["status"] === status && current["progress"] === progress)
+            continue;
+        await state.store.update(state.job, id, { progress, status });
+        if (status === "complete")
+            state.jobStartedAt.delete(id);
+    }
+}
+/**
+ * Records that exist before the API tester arrives — what every real environment has.
+ *
+ * Names alternate case so binary and case-insensitive collations order them differently, some
+ * descriptions are null, and values repeat, so the data looks like a lived-in collection rather
+ * than a fixture. Written straight to the store: none of it is the API tester's to clean up.
+ */
+export async function prepopulate(state, perTenant) {
+    for (const [projectId, count] of [
+        ["proj_alpha", perTenant],
+        ["proj_beta", Math.ceil(perTenant / 10)],
+    ]) {
+        for (let i = 0; i < count; i++)
+            await prepopulateOne(state, projectId, i);
+    }
+}
+const WORDS = ["apple", "Banana", "cherry", "Date", "elder", "Fig", "grape", "Honeydew", "kiwi", "Lemon"];
+async function prepopulateOne(state, projectId, i) {
+    const word = WORDS[i % WORDS.length];
+    const name = `${word} ${projectId === "proj_alpha" ? "" : "beta "}${String(i).padStart(4, "0")}`;
+    const scope = { project_id: projectId };
+    const table = withDefaults(state, { entity: state.table, scope }, {
+        description: i % 3 === 0 ? null : `pre-existing ${word.toLowerCase()} record`,
+        name,
+        position: (i * 7) % 100,
+        slug: name.toLowerCase().replace(/\s+/g, "-"),
+        status: ["active", "draft", "archived"][i % 3],
+    });
+    await state.store.insert(state.table, table);
+    const job = withDefaults(state, { entity: state.job, scope }, { kind: ["export", "import", "sync"][i % 3], name, note: i % 4 === 0 ? null : word });
+    job["status"] = "complete";
+    job["progress"] = 100;
+    await state.store.insert(state.job, job);
+}
+//# sourceMappingURL=store-ops.js.map

package/dist/api/reference/http/validation.d.ts

@@ -0,0 +1,26 @@
+/** What a write body may carry, coerced to the types the schema declares. */
+import type { DefectSet } from "../defects/defect-set.ts";
+import type { EntityDef, FieldDef } from "../model/types.ts";
+import type { Row } from "../store-api.ts";
+/** What a write body is checked against: the entity, the kind of write, and the defects in force. */
+export interface BodyRules {
+    entity: EntityDef;
+    mode: "create" | "update" | "replace";
+    defects: DefectSet;
+    /** Under WRITE_BODY_NOT_VALIDATED: nothing is required, and a value its field refuses is dropped. */
+    lenient?: boolean;
+}
+export declare function validateBody(body: unknown, rules: BodyRules): Row;
+export declare function coerceField(field: FieldDef, value: unknown, defects: DefectSet): unknown;
+/** The value a field takes when nobody supplied one. */
+export declare function emptyValue(field: FieldDef): unknown;
+/** A path identifier as the type its entity declares: a malformed one is a 400, as real frameworks answer before a handler runs. */
+export declare function pathId(entities: readonly EntityDef[], param: string, raw: string): string | number;
+/**
+ * Reads a form-encoded body into the types the schema declares.
+ *
+ * A form carries only strings, so a correct backend coerces each field by its declared type —
+ * exactly what it would have to do in production.
+ */
+export declare function formFields(entity: EntityDef, text: string): Row;
+//# sourceMappingURL=validation.d.ts.map