@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/reference/listing/select.js

@@ -0,0 +1,56 @@
+import { OVERCLAIMED_FIELD } from "../model/fields.js";
+import { SqlError } from "../store-api.js";
+/** `relation(field,field)` inside a sparse fieldset. Both groups take part in every match. */
+export const NESTED = /^([A-Za-z_][\w]*)\(([^()]*)\)$/;
+/** No sparse fieldset at all: every field is served. */
+export function wholeRow(select) {
+    return select === undefined || select === "" || select === "*";
+}
+/** Splits a sparse fieldset on top-level commas, so `id,table(name,status)` is two entries. */
+export function selectEntries(select) {
+    const out = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of select) {
+        if (ch === "(")
+            depth++;
+        if (ch === ")")
+            depth--;
+        if (ch === "," && depth === 0) {
+            out.push(current.trim());
+            current = "";
+        }
+        else
+            current += ch;
+    }
+    out.push(current.trim());
+    return out.filter(Boolean);
+}
+/** The fields a nested entry names: `name,status` of `table(name,status)`. */
+export function nestedFields(list) {
+    return list.split(",").map((field) => field.trim());
+}
+/** Validates a sparse fieldset against the entity before any row is read. */
+export function checkSelect(select, entity, defects) {
+    if (wholeRow(select))
+        return;
+    for (const entry of selectEntries(select)) {
+        const nested = NESTED.exec(entry);
+        if (nested !== null) {
+            const relation = entity.relations?.[nested[1]];
+            const fields = nestedFields(nested[2]);
+            if (relation === undefined || fields.some((field) => !relation.fields.includes(field))) {
+                throw new SqlError("invalid_select", `"${entry}" is not a selectable relation`);
+            }
+            continue;
+        }
+        if (defects.has("SPEC_OVERCLAIMS_SELECTABLE") && entry === OVERCLAIMED_FIELD) {
+            throw new SqlError("invalid_select", `field "${OVERCLAIMED_FIELD}" is not selectable`);
+        }
+        const known = entity.fields.some((field) => field.name === entry);
+        if (!known && entity.filterCatalog?.selectUnknown === "reject" && !defects.has("SELECT_UNKNOWN_IGNORED")) {
+            throw new SqlError("invalid_select", `field "${entry}" is not selectable`);
+        }
+    }
+}
+//# sourceMappingURL=select.js.map

package/dist/api/reference/listing/types.d.ts

@@ -0,0 +1,38 @@
+import type { QueryConventions } from "../query/conventions.ts";
+import type { Row } from "../store-api.ts";
+/** A listing request with every parameter already rewritten into the canonical grammar. */
+export interface ListingRequest {
+    filter?: string | undefined;
+    order?: string | undefined;
+    select?: string | undefined;
+    q?: string | undefined;
+    searchMode?: string | undefined;
+    limit?: string | undefined;
+    page?: string | undefined;
+    offset?: string | undefined;
+    cursor?: string | undefined;
+}
+export interface ListingOptions {
+    /** Parent constraints from the path: `{ project_id, table_id }`. */
+    scope: Record<string, string | number>;
+    conventions: QueryConventions;
+    /**
+     * A ceiling the server applies without documenting it. A request above it is served a short
+     * page rather than rejected — the "clamps silently" behavior many real APIs have.
+     */
+    clampLimit?: number | undefined;
+    /** Applied to each row before projection; the listing-only skew and job progress hook in here. */
+    transform?: ((row: Row) => Row) | undefined;
+    /** Loads the record a relation names for `row`, for a nested select such as `table(name)`. */
+    embed?: ((relation: string, row: Row) => Promise<Row | null>) | undefined;
+}
+export interface ListingResult {
+    items: Row[];
+    count: number;
+    hasMore: boolean;
+    nextCursor: string | null;
+    page: number | null;
+    offset: number;
+    limit: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/api/reference/listing/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/api/reference/listing/window.d.ts

@@ -0,0 +1,23 @@
+import type { DefectSet } from "../defects/defect-set.ts";
+import type { ParseContext } from "../query/conventions.ts";
+import type { Collation } from "../query-types.ts";
+import { type Row } from "../store-api.ts";
+import type { Paging } from "./params.ts";
+/** Where a page starts, and its number where the request paged by number. */
+export interface WindowStart {
+    offset: number;
+    page: number | null;
+}
+export declare function invert(collation: Collation): Collation;
+/** Where a cursor page starts: just past the row the cursor names, in `ordered`. */
+export declare function cursorOffset({ defects, entity }: Pick<ParseContext, "defects" | "entity">, ordered: Row[], afterId: string): number;
+/** Where an offset or numbered page starts over `total` rows. */
+export declare function numberedStart(paging: Paging, total: number, defects: DefectSet): WindowStart;
+/** The rows of the page: `limit` from `offset`, or every row from it when the limit is ignored. */
+export declare function cut(ctx: Pick<ParseContext, "defects">, rows: Row[], { offset }: WindowStart, limit: number): Row[];
+/**
+ * The window after a predicate applied to it alone: FILTER_AFTER_PAGINATION. The empty-result
+ * guard looks at what is about to be returned, wherever the filter ran.
+ */
+export declare function filteredWindow({ defects, entity }: Pick<ParseContext, "defects" | "entity">, window: Row[], matching: Row[]): Row[];
+//# sourceMappingURL=window.d.ts.map

package/dist/api/reference/listing/window.js

@@ -0,0 +1,39 @@
+import { SqlError } from "../store-api.js";
+export function invert(collation) {
+    return collation === "binary" ? "insensitive" : "binary";
+}
+/** Where a cursor page starts: just past the row the cursor names, in `ordered`. */
+export function cursorOffset({ defects, entity }, ordered, afterId) {
+    const index = ordered.findIndex((row) => String(row[entity.identity]) === afterId);
+    if (index === -1)
+        throw new SqlError("invalid_cursor", "cursor does not point into this collection");
+    return index + (defects.has("CURSOR_DRIFT") ? 0 : 1);
+}
+/** Where an offset or numbered page starts over `total` rows. */
+export function numberedStart(paging, total, defects) {
+    if (paging.offset !== undefined) {
+        return { offset: paging.offset + (defects.has("OFF_BY_ONE_PAGE") && paging.offset > 0 ? 1 : 0), page: null };
+    }
+    const page = paging.page ?? 1;
+    const limit = paging.servedLimit;
+    let offset = (page - 1) * limit + (defects.has("OFF_BY_ONE_PAGE") && page > 1 ? 1 : 0);
+    /* A page past the end served as the last page again, instead of empty. */
+    if (defects.has("PAGE_PAST_END_REPEATS") && offset >= total && total > 0) {
+        offset = (Math.ceil(total / limit) - 1) * limit;
+    }
+    return { offset, page };
+}
+/** The rows of the page: `limit` from `offset`, or every row from it when the limit is ignored. */
+export function cut(ctx, rows, { offset }, limit) {
+    return ctx.defects.has("LIMIT_IGNORED") ? rows.slice(offset) : rows.slice(offset, offset + limit);
+}
+/**
+ * The window after a predicate applied to it alone: FILTER_AFTER_PAGINATION. The empty-result
+ * guard looks at what is about to be returned, wherever the filter ran.
+ */
+export function filteredWindow({ defects, entity }, window, matching) {
+    const allowed = new Set(matching.map((row) => String(row[entity.identity])));
+    const filtered = window.filter((row) => allowed.has(String(row[entity.identity])));
+    return defects.has("EMPTY_RESULT_RETURNS_ALL") && filtered.length === 0 ? window : filtered;
+}
+//# sourceMappingURL=window.js.map

package/dist/api/reference/model/entities.d.ts

@@ -0,0 +1,4 @@
+import type { EntityDef } from "./types.ts";
+/** Every entity the reference serves, parents before children. */
+export declare const ENTITIES: readonly EntityDef[];
+//# sourceMappingURL=entities.d.ts.map

package/dist/api/reference/model/entities.js

@@ -0,0 +1,7 @@
+import { JOB } from "./job.js";
+import { ROW } from "./row.js";
+import { TABLE } from "./table.js";
+import { WEBHOOK } from "./webhook.js";
+/** Every entity the reference serves, parents before children. */
+export const ENTITIES = [TABLE, ROW, JOB, WEBHOOK];
+//# sourceMappingURL=entities.js.map

package/dist/api/reference/model/fields.d.ts

@@ -0,0 +1,11 @@
+import type { EntityDef, FieldDef } from "./types.ts";
+/**
+ * The field a spec-overclaim defect withholds from the backend while the document still lists it.
+ *
+ * Chosen as a field every entity has and that no other defect touches, so the overclaim is the
+ * only difference between what the document promises and what the backend accepts.
+ */
+export declare const OVERCLAIMED_FIELD = "created_at";
+export declare function fieldsWhere(entity: EntityDef, key: keyof FieldDef): string[];
+export declare function writableFields(entity: EntityDef, phase: "create" | "update"): FieldDef[];
+//# sourceMappingURL=fields.d.ts.map

package/dist/api/reference/model/fields.js

@@ -0,0 +1,20 @@
+/**
+ * The field a spec-overclaim defect withholds from the backend while the document still lists it.
+ *
+ * Chosen as a field every entity has and that no other defect touches, so the overclaim is the
+ * only difference between what the document promises and what the backend accepts.
+ */
+export const OVERCLAIMED_FIELD = "created_at";
+export function fieldsWhere(entity, key) {
+    return entity.fields.filter((f) => f[key] === true).map((f) => f.name);
+}
+export function writableFields(entity, phase) {
+    return entity.fields.filter((f) => {
+        if (f.generated === true)
+            return false;
+        if (phase === "update" && (f.immutable === true || f.createOnly === true))
+            return false;
+        return true;
+    });
+}
+//# sourceMappingURL=fields.js.map

package/dist/api/reference/model/identity.d.ts

@@ -0,0 +1,8 @@
+import type { EntityDef } from "./types.ts";
+/**
+ * The entity with its identity field called `renamed`. A renamed identity is renamed everywhere:
+ * the document, the query grammar and the store — so the field, the per-field operator catalog
+ * and the unique sets all follow it.
+ */
+export declare function renameIdentity(original: EntityDef, renamed: string): EntityDef;
+//# sourceMappingURL=identity.d.ts.map

package/dist/api/reference/model/identity.js

@@ -0,0 +1,27 @@
+/**
+ * The entity with its identity field called `renamed`. A renamed identity is renamed everywhere:
+ * the document, the query grammar and the store — so the field, the per-field operator catalog
+ * and the unique sets all follow it.
+ */
+export function renameIdentity(original, renamed) {
+    return {
+        ...original,
+        fields: original.fields.map((field) => (field.name === original.identity ? { ...field, name: renamed } : field)),
+        identity: renamed,
+        ...(original.filterCatalog?.opsByField === undefined
+            ? {}
+            : {
+                filterCatalog: {
+                    ...original.filterCatalog,
+                    opsByField: Object.fromEntries(Object.entries(original.filterCatalog.opsByField).map(([field, ops]) => [
+                        field === original.identity ? renamed : field,
+                        ops,
+                    ])),
+                },
+            }),
+        ...(original.unique === undefined
+            ? {}
+            : { unique: original.unique.map((set) => set.map((name) => (name === original.identity ? renamed : name))) }),
+    };
+}
+//# sourceMappingURL=identity.js.map

package/dist/api/reference/model/job.d.ts

@@ -0,0 +1,7 @@
+import type { EntityDef } from "./types.ts";
+/**
+ * An asynchronous job. Present so the async lifecycle — receipt, poll, terminal state — has
+ * something to exercise; extraction, export and batch APIs are all shaped this way.
+ */
+export declare const JOB: EntityDef;
+//# sourceMappingURL=job.d.ts.map

package/dist/api/reference/model/job.js

@@ -0,0 +1,69 @@
+import { TIMESTAMPS } from "./timestamps.js";
+/**
+ * An asynchronous job. Present so the async lifecycle — receipt, poll, terminal state — has
+ * something to exercise; extraction, export and batch APIs are all shaped this way.
+ */
+export const JOB = {
+    collectionPath: "/v1/projects/{project_id}/jobs",
+    defaultLimit: 20,
+    defaultOrder: "created_at.desc",
+    fields: [
+        { generated: true, immutable: true, name: "id", required: true, sortable: true, filterable: true, type: "string" },
+        { generated: true, immutable: true, name: "project_id", required: true, filterable: true, type: "string" },
+        {
+            filterable: true,
+            maxLength: 128,
+            name: "name",
+            required: true,
+            searchable: true,
+            sortable: true,
+            type: "string",
+        },
+        /* A second freely-writable string, purely so the concurrency check has two independent
+         * fields to race on. With only `name` writable it could never establish that two patches
+         * to *different* fields both survive, and it stood down on every run. */
+        {
+            filterable: true,
+            maxLength: 256,
+            name: "note",
+            nullable: true,
+            searchable: true,
+            sortable: true,
+            type: "string",
+        },
+        /*
+         * A low-cardinality field the *client* sets.
+         *
+         * Every other field on this entity is either unique per record or server-generated, which
+         * left no value shared by some records but not all — so any property asserted over a
+         * proper subset (a filter that matches several rows and excludes others) had nothing to
+         * work with and stood down. Real collections always have a repeated dimension; a fixture
+         * without one silently narrows what can be tested.
+         */
+        {
+            enum: ["export", "import", "sync"],
+            filterable: true,
+            name: "kind",
+            sortable: true,
+            type: "string",
+        },
+        {
+            enum: ["pending", "running", "complete", "failed"],
+            filterable: true,
+            generated: true,
+            name: "status",
+            sortable: true,
+            type: "string",
+        },
+        { filterable: true, generated: true, name: "progress", sortable: true, type: "integer" },
+        ...TIMESTAMPS,
+    ],
+    identity: "id",
+    itemParam: "job_id",
+    itemPath: "/v1/projects/{project_id}/jobs/{job_id}",
+    maxLimit: 100,
+    name: "job",
+    parents: ["project_id"],
+    plural: "jobs",
+};
+//# sourceMappingURL=job.js.map

package/dist/api/reference/model/row.d.ts

@@ -0,0 +1,4 @@
+import type { EntityDef } from "./types.ts";
+/** A row of a table: numbers, booleans, a nullable note and an array, under a small page ceiling. */
+export declare const ROW: EntityDef;
+//# sourceMappingURL=row.d.ts.map

package/dist/api/reference/model/row.js

@@ -0,0 +1,46 @@
+import { TIMESTAMPS } from "./timestamps.js";
+/** A row of a table: numbers, booleans, a nullable note and an array, under a small page ceiling. */
+export const ROW = {
+    collectionPath: "/v1/projects/{project_id}/tables/{table_id}/rows",
+    defaultLimit: 20,
+    defaultOrder: "created_at.desc",
+    fields: [
+        { generated: true, immutable: true, name: "id", required: true, sortable: true, filterable: true, type: "string" },
+        { generated: true, immutable: true, name: "table_id", required: true, filterable: true, type: "string" },
+        {
+            filterable: true,
+            maxLength: 128,
+            name: "label",
+            required: true,
+            searchable: true,
+            sortable: true,
+            type: "string",
+        },
+        { filterable: true, name: "amount", sortable: true, type: "number" },
+        {
+            filterable: true,
+            name: "note",
+            nullable: true,
+            searchable: true,
+            sortable: true,
+            maxLength: 256,
+            type: "string",
+        },
+        { filterable: true, name: "active", sortable: true, type: "boolean" },
+        /* An array, so set membership (`contains`) has something real to test. The elements are
+         * chosen so one is a prefix of another: matching by substring is then visibly wrong. */
+        { filterable: true, items: ["red", "redwood", "blue", "green"], name: "tags", type: "array" },
+        ...TIMESTAMPS,
+    ],
+    identity: "id",
+    itemParam: "row_id",
+    relations: { table: { entity: "table", fields: ["name", "status"], via: "table_id" } },
+    itemPath: "/v1/projects/{project_id}/tables/{table_id}/rows/{row_id}",
+    /* Deliberately below the default cohort size so the cap is observable at all — a limit
+     * ceiling no request can reach cannot be tested. */
+    maxLimit: 5,
+    name: "row",
+    parents: ["project_id", "table_id"],
+    plural: "rows",
+};
+//# sourceMappingURL=row.js.map

package/dist/api/reference/model/shaped.d.ts

@@ -0,0 +1,10 @@
+import type { EntityDef, EntityShape } from "./types.ts";
+/**
+ * The entities as a given shape serves them.
+ *
+ * A shape changes what the records look like — the identifier format, extra fields a real schema
+ * would carry — without changing what a correct backend does with them. Copies are returned, so
+ * one server's shape never leaks into another's.
+ */
+export declare function shapedEntities(shape: EntityShape): EntityDef[];
+//# sourceMappingURL=shaped.d.ts.map

package/dist/api/reference/model/shaped.js

@@ -0,0 +1,33 @@
+import { ENTITIES } from "./entities.js";
+import { renameIdentity } from "./identity.js";
+import { TABLE } from "./table.js";
+import { guardStrings } from "./string-guard.js";
+import { shapeTable } from "./table-shape.js";
+/**
+ * The entities as a given shape serves them.
+ *
+ * A shape changes what the records look like — the identifier format, extra fields a real schema
+ * would carry — without changing what a correct backend does with them. Copies are returned, so
+ * one server's shape never leaks into another's.
+ */
+export function shapedEntities(shape) {
+    const linkParams = new Set(ENTITIES.map((entity) => entity.itemParam));
+    return ENTITIES.map((original) => {
+        /* The async job keeps its own identity: its receipt and poll route are keyed on `id`. */
+        const renamed = original.name === "job" ? undefined : shape.identityField;
+        const entity = renamed === undefined || renamed === original.identity ? original : renameIdentity(original, renamed);
+        const fields = entity.fields.map((field) => field.name === entity.identity || linkParams.has(field.name) ? idField(field, shape.ids) : { ...field });
+        const unique = entity.name === TABLE.name ? shapeTable(entity, fields, shape) : entity.unique;
+        const served = shape.stringGuard === true ? guardStrings(fields) : fields;
+        return { ...entity, fields: served, ...(unique === undefined ? {} : { unique }) };
+    });
+}
+/* An identity, or a parent's identity a path carries, in the shape's identifier format. */
+function idField(field, ids) {
+    if (ids === "uuid")
+        return { ...field, format: "uuid", type: "string" };
+    if (ids === "integer")
+        return { ...field, type: "integer" };
+    return field;
+}
+//# sourceMappingURL=shaped.js.map

package/dist/api/reference/model/string-guard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The write guard some generators publish on every written string: no NUL and no unpaired
+ * surrogate, as a pattern compiled with the `u` flag. A field with a pattern of its own carries
+ * both, which a document writes as an `allOf`.
+ */
+import type { FieldDef } from "./types.ts";
+export declare const STRING_GUARD = "^[^\\u0000\\uD800-\\uDFFF]*$";
+/** An E.164 telephone number: the pattern of its own a guarded `phone` field carries. */
+export declare const PHONE_PATTERN = "^\\+[1-9]\\d{7,14}$";
+/** `fields` with the guard after each written string's own patterns; generated fields are never written. */
+export declare function guardStrings(fields: readonly FieldDef[]): FieldDef[];
+//# sourceMappingURL=string-guard.d.ts.map

package/dist/api/reference/model/string-guard.js

@@ -0,0 +1,15 @@
+/**
+ * The write guard some generators publish on every written string: no NUL and no unpaired
+ * surrogate, as a pattern compiled with the `u` flag. A field with a pattern of its own carries
+ * both, which a document writes as an `allOf`.
+ */
+export const STRING_GUARD = "^[^\\u0000\\uD800-\\uDFFF]*$";
+/** An E.164 telephone number: the pattern of its own a guarded `phone` field carries. */
+export const PHONE_PATTERN = "^\\+[1-9]\\d{7,14}$";
+/** `fields` with the guard after each written string's own patterns; generated fields are never written. */
+export function guardStrings(fields) {
+    return fields.map((field) => field.type === "string" && field.generated !== true
+        ? { ...field, patterns: [...(field.patterns ?? []), STRING_GUARD] }
+        : field);
+}
+//# sourceMappingURL=string-guard.js.map

package/dist/api/reference/model/table-shape.d.ts

@@ -0,0 +1,7 @@
+import type { EntityDef, EntityShape, FieldDef } from "./types.ts";
+/**
+ * Lays a shape's table changes over `fields`, in place, and returns the unique sets the table
+ * then keeps. `fields` holds the table's identity field and its `slug`: every table does.
+ */
+export declare function shapeTable(entity: EntityDef, fields: FieldDef[], shape: EntityShape): string[][] | undefined;
+//# sourceMappingURL=table-shape.d.ts.map

package/dist/api/reference/model/table-shape.js

@@ -0,0 +1,68 @@
+import { PHONE_PATTERN } from "./string-guard.js";
+/**
+ * Lays a shape's table changes over `fields`, in place, and returns the unique sets the table
+ * then keeps. `fields` holds the table's identity field and its `slug`: every table does.
+ */
+export function shapeTable(entity, fields, shape) {
+    let unique = entity.unique;
+    const clientIds = shape.clientIds;
+    if (clientIds !== undefined) {
+        /* The client names the table: its id is a bounded, required, unique create field. */
+        const at = fields.findIndex((field) => field.name === entity.identity);
+        fields[at] = {
+            ...fields[at],
+            generated: false,
+            maximum: clientIds.max,
+            minimum: clientIds.min,
+            required: true,
+            type: "integer",
+        };
+        unique = [...entity.unique, [entity.identity]];
+    }
+    if (shape.tableKey === "slug") {
+        /* The server derives it from the name; it is as long as a name may be. */
+        const at = fields.findIndex((field) => field.name === "slug");
+        fields[at] = { ...fields[at], generated: true, maxLength: 128, required: true };
+        /* Names may repeat across projects and the document declares nothing unique: the
+         * server refuses only a slug its project already holds. */
+        unique = [];
+    }
+    fields.push(...extraFields(shape));
+    return unique;
+}
+/** The fields a shape adds to the table, in the order the document lists them. */
+function extraFields(shape) {
+    return [
+        ...(shape.writeOnlyField === true
+            ? [{ maxLength: 64, name: "secret", required: true, type: "string", writeOnly: true }]
+            : []),
+        ...(shape.richSchema === true ? richFields() : []),
+        ...(shape.stringGuard === true
+            ? [
+                {
+                    maxLength: 15,
+                    minLength: 7,
+                    name: "phone",
+                    nullable: true,
+                    patterns: [PHONE_PATTERN],
+                    type: "string",
+                },
+            ]
+            : []),
+        ...(shape.largeRecords === true ? [{ generated: true, name: "padding", type: "string" }] : []),
+        ...(shape.specLayout === true
+            ? [{ generated: true, name: "tree", nullable: true, ref: "TreeNode", type: "object" }]
+            : []),
+    ];
+}
+/* Required date-time, a bounded number, a `const`, and one component schema used twice. */
+function richFields() {
+    return [
+        { format: "date-time", name: "due_at", required: true, type: "string" },
+        { maximum: 10, minimum: 1, multipleOf: 0.5, name: "weight", required: true, type: "number" },
+        { const: "v1", name: "schema_version", required: true, type: "string" },
+        { name: "start", ref: "Point", required: true, type: "object" },
+        { name: "end", ref: "Point", required: true, type: "object" },
+    ];
+}
+//# sourceMappingURL=table-shape.js.map

package/dist/api/reference/model/table.d.ts

@@ -0,0 +1,4 @@
+import type { EntityDef } from "./types.ts";
+/** A project's table: the root entity every tenant creates first. */
+export declare const TABLE: EntityDef;
+//# sourceMappingURL=table.d.ts.map

package/dist/api/reference/model/table.js

@@ -0,0 +1,72 @@
+import { TIMESTAMPS } from "./timestamps.js";
+/** A project's table: the root entity every tenant creates first. */
+export const TABLE = {
+    collectionPath: "/v1/projects/{project_id}/tables",
+    defaultLimit: 20,
+    defaultOrder: "created_at.desc",
+    fields: [
+        { generated: true, immutable: true, name: "id", required: true, sortable: true, filterable: true, type: "string" },
+        { generated: true, immutable: true, name: "project_id", required: true, filterable: true, type: "string" },
+        {
+            filterable: true,
+            maxLength: 128,
+            name: "name",
+            required: true,
+            searchable: true,
+            sortable: true,
+            type: "string",
+        },
+        { filterable: true, name: "slug", searchable: true, sortable: true, maxLength: 64, type: "string" },
+        {
+            enum: ["active", "draft", "archived"],
+            filterable: true,
+            name: "status",
+            sortable: true,
+            type: "string",
+        },
+        { filterable: true, name: "position", sortable: true, type: "integer" },
+        { filterable: true, maxLength: 256, name: "description", nullable: true, sortable: true, type: "string" },
+        /* Set by an admin alone: the field the privileged-field check writes as a lower rank. */
+        { name: "verified", privileged: true, type: "boolean" },
+        ...TIMESTAMPS,
+        { filterable: true, generated: true, name: "deleted_at", nullable: true, sortable: true, type: "integer" },
+        /*
+         * Derived from another entity: the number of rows this table holds.
+         *
+         * Its purpose is to make `x-invalidate` mean something testable. Without a field whose
+         * value depends on a *different* entity's writes, "creating a row invalidates the tables
+         * listing" is a claim no observation can contradict.
+         */
+        { filterable: true, generated: true, name: "row_count", sortable: true, type: "integer" },
+    ],
+    identity: "id",
+    itemParam: "table_id",
+    itemPath: "/v1/projects/{project_id}/tables/{table_id}",
+    maxLimit: 100,
+    name: "table",
+    parents: ["project_id"],
+    plural: "tables",
+    softDeleteField: "deleted_at",
+    unique: [["name"]],
+    filterCatalog: {
+        aliases: { ne: "neq" },
+        emptyIn: "match-none",
+        maxFilterConditions: 20,
+        maxInValues: 100,
+        opsByField: {
+            created_at: ["eq", "gt", "gte", "lt", "lte", "is"],
+            deleted_at: ["eq", "is"],
+            description: ["eq", "neq", "like", "ilike", "is"],
+            id: ["eq", "neq", "ne", "in", "nin"],
+            name: ["eq", "neq", "like", "ilike", "in"],
+            position: ["eq", "neq", "gt", "gte", "lt", "lte", "in"],
+            project_id: ["eq", "neq", "in"],
+            row_count: ["eq", "gt", "gte", "lt", "lte"],
+            slug: ["eq", "neq", "like", "ilike", "in"],
+            status: ["eq", "neq", "in", "nin"],
+            updated_at: ["eq", "gt", "gte", "lt", "lte", "is"],
+        },
+        selectUnknown: "reject",
+    },
+};
+//# sourceMappingURL=table.js.map

package/dist/api/reference/model/timestamps.d.ts

@@ -0,0 +1,4 @@
+import type { FieldDef } from "./types.ts";
+/** The creation and update instants every entity carries; the server sets both. */
+export declare const TIMESTAMPS: FieldDef[];
+//# sourceMappingURL=timestamps.d.ts.map

package/dist/api/reference/model/timestamps.js

@@ -0,0 +1,6 @@
+/** The creation and update instants every entity carries; the server sets both. */
+export const TIMESTAMPS = [
+    { filterable: true, generated: true, name: "created_at", sortable: true, type: "integer" },
+    { filterable: true, generated: true, name: "updated_at", sortable: true, type: "integer" },
+];
+//# sourceMappingURL=timestamps.js.map