@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/reference/spec/schemas.js

@@ -0,0 +1,204 @@
+/** The record, body and listing schemas a document declares for each entity. */
+import { writableFields } from "../model/fields.js";
+/* A string's lengths and patterns: one pattern as itself, more as an `allOf`, as generators emit them. */
+function stringBounds(field, base) {
+    if (field.maxLength !== undefined)
+        base.maxLength = field.maxLength;
+    if (field.minLength !== undefined)
+        base.minLength = field.minLength;
+    const patterns = field.patterns ?? [];
+    if (patterns.length === 1)
+        base.pattern = patterns[0];
+    if (patterns.length > 1)
+        base.allOf = patterns.map((pattern) => ({ pattern }));
+}
+export function fieldSchema(field) {
+    const base = field.ref === undefined ? { type: field.type } : { $ref: `#/components/schemas/${field.ref}` };
+    if (field.type === "array") {
+        base.items = { enum: [...(field.items ?? [])], type: "string" };
+        base.maxItems = 5;
+    }
+    if (field.format !== undefined)
+        base.format = field.format;
+    if (field.minimum !== undefined)
+        base.minimum = field.minimum;
+    if (field.maximum !== undefined)
+        base.maximum = field.maximum;
+    if (field.multipleOf !== undefined)
+        base.multipleOf = field.multipleOf;
+    if (field.const !== undefined)
+        base.const = field.const;
+    if (field.enum !== undefined)
+        base.enum = [...field.enum];
+    stringBounds(field, base);
+    if (field.generated === true)
+        base.readOnly = true;
+    if (field.writeOnly === true)
+        base.writeOnly = true;
+    if (field.privileged === true)
+        base["x-privileged"] = true;
+    if (field.nullable === true)
+        return { oneOf: [base, { type: "null" }] };
+    return base;
+}
+export function itemSchema(entity) {
+    const properties = {};
+    for (const field of entity.fields)
+        properties[field.name] = fieldSchema(field);
+    return {
+        additionalProperties: false,
+        properties,
+        required: entity.fields.filter((f) => f.required === true).map((f) => f.name),
+        type: "object",
+    };
+}
+export function schemaName(entity) {
+    return `${entity.name[0]?.toUpperCase() ?? ""}${entity.name.slice(1)}`;
+}
+/** An entity's record schema — inline, or a reference into `components` under the layout shape. */
+export function itemSchemaRef(ctx, entity) {
+    if (ctx.shape.specLayout === true)
+        return { $ref: `#/components/schemas/${schemaName(entity)}` };
+    const schema = itemSchema(entity);
+    if (ctx.shape.relatedRecord === true) {
+        const id = ctx.shape.identityField ?? "id";
+        schema.properties["Status"] = {
+            additionalProperties: false,
+            properties: { Name: { type: "string" }, [id]: { type: "integer" } },
+            readOnly: true,
+            required: [id, "Name"],
+            type: "object",
+        };
+        schema.required.push("Status");
+    }
+    return schema;
+}
+/* Under `recordEnvelope`: the answers' shapes, and where the document says the record is. */
+const FIELD_LIST = {
+    items: {
+        additionalProperties: false,
+        properties: { name: { type: "string" }, type: { type: "string" } },
+        required: ["name", "type"],
+        type: "object",
+    },
+    type: "array",
+};
+function identitySchema(entity) {
+    const field = entity.fields.find((candidate) => candidate.name === entity.identity);
+    return field === undefined ? { type: "string" } : fieldSchema(field);
+}
+/* The async job is an action's receipt, not a record: its answers stay plain. */
+function wraps(ctx, entity) {
+    return ctx.shape.recordEnvelope === true && entity.name !== "job";
+}
+export function createdSchema(ctx, entity) {
+    if (!wraps(ctx, entity))
+        return itemSchemaRef(ctx, entity);
+    return {
+        additionalProperties: false,
+        properties: {
+            data: itemSchemaRef(ctx, entity),
+            id: identitySchema(entity),
+            message: { type: "string" },
+            success: { type: "boolean" },
+        },
+        required: ["success", "id", "message", "data"],
+        type: "object",
+    };
+}
+/** Under `createAnswer: "id-message"`: the acknowledgment a create answers instead of the record. */
+export function acknowledgmentSchema(entity) {
+    return {
+        additionalProperties: false,
+        properties: { id: identitySchema(entity), message: { type: "string" } },
+        required: ["id", "message"],
+        type: "object",
+    };
+}
+export function readSchema(ctx, entity) {
+    if (!wraps(ctx, entity))
+        return itemSchemaRef(ctx, entity);
+    return {
+        additionalProperties: false,
+        properties: { data: itemSchemaRef(ctx, entity), fields: FIELD_LIST },
+        required: ["data", "fields"],
+        type: "object",
+    };
+}
+export function writtenSchema(ctx, entity) {
+    if (!wraps(ctx, entity))
+        return itemSchemaRef(ctx, entity);
+    return {
+        additionalProperties: false,
+        properties: { id: identitySchema(entity), message: { type: "string" }, success: { type: "boolean" } },
+        required: ["success", "id", "message"],
+        type: "object",
+    };
+}
+export function located(ctx, entity, action) {
+    if (!wraps(ctx, entity))
+        return {};
+    return action === "create" ? { createdIdFrom: "$.id", recordPath: "$.data" } : { recordPath: "$.data" };
+}
+export function bodySchema(entity, phase, replace = false) {
+    const properties = {};
+    for (const field of writableFields(entity, phase))
+        properties[field.name] = fieldSchema(field);
+    return {
+        additionalProperties: false,
+        properties,
+        /* A create, and a replacing update, must carry every required field; a PATCH need not. */
+        required: phase === "create" || replace
+            ? writableFields(entity, phase)
+                .filter((f) => f.required === true)
+                .map((f) => f.name)
+            : [],
+        type: "object",
+    };
+}
+/** The collection's property name under a dialect — entity-named, or a fixed key like `data`. */
+function collectionKey(entity, dialect) {
+    return dialect.envelope?.collection ?? entity.plural;
+}
+/* Under `wrappedRows`: a listed row, its record under `document` beside the search's highlights. */
+function wrappedRow(ctx, entity) {
+    const highlight = { properties: { field: { type: "string" }, snippet: { type: "string" } }, type: "object" };
+    return {
+        additionalProperties: false,
+        properties: { document: itemSchemaRef(ctx, entity), highlights: { items: highlight, type: "array" } },
+        required: ["document", "highlights"],
+        type: "object",
+    };
+}
+/** Where the list says its records are: inside each row under `wrappedRows`, an envelope's `data` under `recordEnvelope`. */
+export function listLocated(ctx, entity, dialect) {
+    if (ctx.shape.wrappedRows !== true)
+        return located(ctx, entity, "list");
+    return dialect.envelope === null ? {} : { recordPath: `$.${collectionKey(entity, dialect)}[*].document` };
+}
+export function listSchema(ctx, entity, dialect) {
+    const env = dialect.envelope;
+    /* No envelope: the response *is* the array. A document that says so is the only place the API tester can
+     * learn it, so the schema has to say it rather than describe a wrapper that does not exist. */
+    if (env === null)
+        return { items: itemSchemaRef(ctx, entity), type: "array" };
+    const key = collectionKey(entity, dialect);
+    const row = ctx.shape.wrappedRows === true ? wrappedRow(ctx, entity) : itemSchemaRef(ctx, entity);
+    const properties = { [key]: { items: row, type: "array" } };
+    const required = [key];
+    const declare = (name, schema) => {
+        if (name === undefined)
+            return;
+        properties[name] = schema;
+        required.push(name);
+    };
+    declare(env.hasMore, { type: "boolean" });
+    declare(env.limit, { minimum: 1, type: "integer" });
+    declare(env.page, { oneOf: [{ minimum: 1, type: "integer" }, { type: "null" }] });
+    declare(env.total, { minimum: 0, type: "integer" });
+    declare(env.nextCursor, { oneOf: [{ type: "string" }, { type: "null" }] });
+    if (wraps(ctx, entity))
+        declare("fields", FIELD_LIST);
+    return { additionalProperties: false, properties, required, type: "object" };
+}
+//# sourceMappingURL=schemas.js.map

package/dist/api/reference/spec/security.d.ts

@@ -0,0 +1,10 @@
+/** The document's security: a bearer JWT everywhere by default, or an entity-scoped API key on record routes. */
+import type { EntityDef } from "../model/types.ts";
+import type { Json } from "./types.ts";
+/** The schemes: a bearer JWT, and an API key sent in Authorization as `ApiKey <key>`. */
+export declare const SECURITY_SCHEMES: Json;
+/** What every operation needs unless it says otherwise: the JWT. */
+export declare const ROOT_SECURITY: Json[];
+/** A record route's path item, each operation taking a JWT or an API key with the entity's read or write scope. */
+export declare function securedByEntity(entity: EntityDef, item: Json): Json;
+//# sourceMappingURL=security.d.ts.map

package/dist/api/reference/spec/security.js

@@ -0,0 +1,19 @@
+/** The document's security: a bearer JWT everywhere by default, or an entity-scoped API key on record routes. */
+import { SAFE } from "../../spec/methods.js";
+/** The schemes: a bearer JWT, and an API key sent in Authorization as `ApiKey <key>`. */
+export const SECURITY_SCHEMES = {
+    apiKey: { description: "ApiKey <key>", in: "header", name: "Authorization", type: "apiKey" },
+    jwt: { bearerFormat: "JWT", scheme: "bearer", type: "http" },
+};
+/** What every operation needs unless it says otherwise: the JWT. */
+export const ROOT_SECURITY = [{ jwt: [] }];
+/** A record route's path item, each operation taking a JWT or an API key with the entity's read or write scope. */
+export function securedByEntity(entity, item) {
+    const out = {};
+    for (const [method, operation] of Object.entries(item)) {
+        const access = SAFE.has(method.toUpperCase()) ? "read" : "write";
+        out[method] = { ...operation, security: [{ jwt: [] }, { apiKey: [`${entity.name}:${access}`] }] };
+    }
+    return out;
+}
+//# sourceMappingURL=security.js.map

package/dist/api/reference/spec/styles.d.ts

@@ -0,0 +1,8 @@
+/** A route whose query is written in two OAS styles: a deepObject range and pipe-delimited ids. */
+import type { Json, SpecContext } from "./types.ts";
+/**
+ * `GET /v1/styles`, public. The server answers 200 only when both values arrive in their declared
+ * style, so a client that writes either in another style is refused, and its contract call fails.
+ */
+export declare function stylePaths(ctx: SpecContext): Json;
+//# sourceMappingURL=styles.d.ts.map

package/dist/api/reference/spec/styles.js

@@ -0,0 +1,55 @@
+/** A route whose query is written in two OAS styles: a deepObject range and pipe-delimited ids. */
+import { errorResponses } from "./errors.js";
+import { jsonResponse, ok } from "./operation.js";
+const RANGE = {
+    additionalProperties: false,
+    properties: { max: { type: "integer" }, min: { type: "integer" } },
+    required: ["min", "max"],
+    type: "object",
+};
+const IDS = { items: { pattern: "^[a-z0-9_]+$", type: "string" }, minItems: 1, type: "array" };
+/**
+ * `GET /v1/styles`, public. The server answers 200 only when both values arrive in their declared
+ * style, so a client that writes either in another style is refused, and its contract call fails.
+ */
+export function stylePaths(ctx) {
+    return {
+        "/v1/styles": {
+            get: {
+                operationId: "styles.read",
+                parameters: [
+                    {
+                        example: { max: 5, min: 1 },
+                        in: "query",
+                        name: "range",
+                        required: true,
+                        schema: RANGE,
+                        style: "deepObject",
+                    },
+                    {
+                        example: ["a", "b"],
+                        explode: false,
+                        in: "query",
+                        name: "ids",
+                        required: true,
+                        schema: IDS,
+                        style: "pipeDelimited",
+                    },
+                ],
+                responses: {
+                    [ok(ctx, 200)]: jsonResponse("The range and ids as the server parsed them", {
+                        additionalProperties: false,
+                        properties: { ids: IDS, range: RANGE },
+                        required: ["range", "ids"],
+                        type: "object",
+                    }),
+                    ...errorResponses(ctx, [400]),
+                },
+                security: [],
+                summary: "Echo styled query parameters",
+                tags: ["Styles"],
+            },
+        },
+    };
+}
+//# sourceMappingURL=styles.js.map

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

@@ -0,0 +1,9 @@
+import type { EntityDef } from "../model/types.ts";
+import type { ReferenceShape } from "../shapes/types.ts";
+export type Json = Record<string, unknown>;
+/** What a document is generated from: the entities as this server serves them, and its shape. */
+export interface SpecContext {
+    entities: readonly EntityDef[];
+    shape: ReferenceShape;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -0,0 +1,34 @@
+/**
+ * Storage contract shared by the reference backends.
+ *
+ * A store is deliberately dumb: it persists rows and answers "which rows match this predicate, in
+ * this order". Parsing, validation, paging, projection and every defect that is not a property of
+ * the engine itself live above it (see `query/` and `listing/`), so they are written once and
+ * every engine exhibits them identically.
+ *
+ * What the engines are still free to disagree on is what engines genuinely disagree on: how they
+ * compile a predicate, how their collations order text, and how their type systems store values.
+ * Where two stores then disagree, that is a real difference, not two implementations drifting.
+ *
+ * Async throughout, because a real database is: SQLite implementations resolve immediately.
+ */
+import type { EntityDef } from "./model/types.ts";
+import type { SelectPlan } from "./query-types.ts";
+export type Row = Record<string, unknown>;
+export interface Store {
+    close(): Promise<void>;
+    insert(entity: EntityDef, record: Row): Promise<Row>;
+    byId(entity: EntityDef, id: string | number): Promise<Row | null>;
+    update(entity: EntityDef, id: string | number, patch: Row): Promise<Row | null>;
+    remove(entity: EntityDef, id: string | number): Promise<void>;
+    /** Every row matching `plan.where`, ordered by `plan.order`. Paging happens above the store. */
+    select(entity: EntityDef, plan: SelectPlan): Promise<Row[]>;
+}
+/** Raised for input the storage layer rejects — surfaces as 400, or 500 under the defect. */
+export declare class SqlError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function encodeCursor(id: string): string;
+export declare function decodeCursor(cursor: string): string;
+//# sourceMappingURL=store-api.d.ts.map

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

@@ -0,0 +1,37 @@
+/**
+ * Storage contract shared by the reference backends.
+ *
+ * A store is deliberately dumb: it persists rows and answers "which rows match this predicate, in
+ * this order". Parsing, validation, paging, projection and every defect that is not a property of
+ * the engine itself live above it (see `query/` and `listing/`), so they are written once and
+ * every engine exhibits them identically.
+ *
+ * What the engines are still free to disagree on is what engines genuinely disagree on: how they
+ * compile a predicate, how their collations order text, and how their type systems store values.
+ * Where two stores then disagree, that is a real difference, not two implementations drifting.
+ *
+ * Async throughout, because a real database is: SQLite implementations resolve immediately.
+ */
+/** Raised for input the storage layer rejects — surfaces as 400, or 500 under the defect. */
+export class SqlError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export function encodeCursor(id) {
+    return Buffer.from(JSON.stringify({ id }), "utf8").toString("base64url");
+}
+export function decodeCursor(cursor) {
+    try {
+        const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+        if (typeof parsed.id !== "string")
+            throw new Error("missing id");
+        return parsed.id;
+    }
+    catch {
+        throw new SqlError("invalid_cursor", "cursor is not a value produced by this API");
+    }
+}
+//# sourceMappingURL=store-api.js.map

package/dist/api/reference/stores/memory.d.ts

@@ -0,0 +1,29 @@
+/**
+ * In-memory storage for the reference backend.
+ *
+ * The zero-dependency fallback: no database, no flags, no server to have running. It evaluates the
+ * query AST in JavaScript, which is exactly why the SQL stores exist alongside it — a JS store
+ * cannot exhibit an engine's collation or type affinity, so a check that only ever runs here has
+ * not been proven against anything a real backend does.
+ */
+import type { EntityDef } from "../model/types.ts";
+import type { SelectPlan } from "../query-types.ts";
+import type { Row, Store } from "../store-api.ts";
+export declare class MemoryStore implements Store {
+    private readonly tables;
+    /**
+     * Per entity, advances per shuffled query so tied rows land differently each time — see
+     * UNSTABLE_SORT. Kept per entity, so one lane's queries never move another's: lanes answer in
+     * whatever order the server is scheduled, and a shared count would make the defect's report
+     * depend on that timing.
+     */
+    private readonly rotations;
+    close(): Promise<void>;
+    private collection;
+    insert(entity: EntityDef, record: Row): Promise<Row>;
+    byId(entity: EntityDef, id: string | number): Promise<Row | null>;
+    update(entity: EntityDef, id: string | number, patch: Row): Promise<Row | null>;
+    remove(entity: EntityDef, id: string | number): Promise<void>;
+    select(entity: EntityDef, plan: SelectPlan): Promise<Row[]>;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/api/reference/stores/memory.js

@@ -0,0 +1,66 @@
+/**
+ * In-memory storage for the reference backend.
+ *
+ * The zero-dependency fallback: no database, no flags, no server to have running. It evaluates the
+ * query AST in JavaScript, which is exactly why the SQL stores exist alongside it — a JS store
+ * cannot exhibit an engine's collation or type affinity, so a check that only ever runs here has
+ * not been proven against anything a real backend does.
+ */
+import { compareRows } from "../query/compare.js";
+import { evaluate } from "../query/evaluate.js";
+export class MemoryStore {
+    tables = new Map();
+    /**
+     * Per entity, advances per shuffled query so tied rows land differently each time — see
+     * UNSTABLE_SORT. Kept per entity, so one lane's queries never move another's: lanes answer in
+     * whatever order the server is scheduled, and a shared count would make the defect's report
+     * depend on that timing.
+     */
+    rotations = new Map();
+    async close() {
+        this.tables.clear();
+        this.rotations.clear();
+    }
+    collection(entity) {
+        const existing = this.tables.get(entity.name);
+        if (existing !== undefined)
+            return existing;
+        const created = new Map();
+        this.tables.set(entity.name, created);
+        return created;
+    }
+    async insert(entity, record) {
+        const stored = { ...record };
+        this.collection(entity).set(String(record[entity.identity]), stored);
+        return { ...stored };
+    }
+    async byId(entity, id) {
+        const found = this.collection(entity).get(String(id));
+        return found === undefined ? null : { ...found };
+    }
+    async update(entity, id, patch) {
+        const existing = this.collection(entity).get(String(id));
+        if (existing === undefined)
+            return null;
+        const next = { ...existing, ...patch };
+        this.collection(entity).set(String(id), next);
+        return { ...next };
+    }
+    async remove(entity, id) {
+        this.collection(entity).delete(String(id));
+    }
+    async select(entity, plan) {
+        let rows = [...this.collection(entity).values()].filter((row) => evaluate(plan.where, row));
+        /* Array.prototype.sort is stable, so dropping the tiebreak alone would still yield one
+         * deterministic order and the defect would be unobservable. A database without a tiebreak
+         * returns tied rows in whatever order the plan produced, varying between queries; rotating
+         * the input reproduces that. */
+        if (plan.shuffleTies && rows.length > 1) {
+            const rotation = ((this.rotations.get(entity.name) ?? 0) + 1) % rows.length;
+            this.rotations.set(entity.name, rotation);
+            rows = [...rows.slice(rotation), ...rows.slice(0, rotation)];
+        }
+        return rows.sort(compareRows(plan.order, plan.collation)).map((row) => ({ ...row }));
+    }
+}
+//# sourceMappingURL=memory.js.map

package/dist/api/reference/stores/postgres-driver.d.ts

@@ -0,0 +1,9 @@
+/** The driver range package.json declares as the optional peer (tests/structure/postgres-driver.test.ts). */
+export declare const POSTGRES_RANGE = "^3.4";
+/** What a command says, and exits 2 with, when the Postgres backend is asked for on an install without the driver. */
+export declare const MISSING_POSTGRES: string;
+/** Whether `error` is Node failing to find the `postgres` package itself, not a module it imports. */
+export declare function isMissingPostgres(error: unknown): boolean;
+/** What `load` resolves, or a usage error asking for the driver when the install lacks it. */
+export declare function loadPostgres<T>(load: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=postgres-driver.d.ts.map

package/dist/api/reference/stores/postgres-driver.js

@@ -0,0 +1,27 @@
+import { UsageError } from "../../errors/usage-error.js";
+/*
+ * `postgres` (postgres.js) is an optional peer dependency: only the Postgres reference backend uses
+ * it, so an install without it runs every other command, and the Postgres path asks for it by name.
+ */
+/** The driver range package.json declares as the optional peer (tests/structure/postgres-driver.test.ts). */
+export const POSTGRES_RANGE = "^3.4";
+/** What a command says, and exits 2 with, when the Postgres backend is asked for on an install without the driver. */
+export const MISSING_POSTGRES = `testing api: --backend postgres needs the postgres package (${POSTGRES_RANGE}): npm install postgres`;
+/** Whether `error` is Node failing to find the `postgres` package itself, not a module it imports. */
+export function isMissingPostgres(error) {
+    return (error instanceof Error &&
+        error.code === "ERR_MODULE_NOT_FOUND" &&
+        error.message.includes("'postgres'"));
+}
+/** What `load` resolves, or a usage error asking for the driver when the install lacks it. */
+export async function loadPostgres(load) {
+    try {
+        return await load();
+    }
+    catch (error) {
+        if (!isMissingPostgres(error))
+            throw error;
+        throw new UsageError(MISSING_POSTGRES, { cause: error });
+    }
+}
+//# sourceMappingURL=postgres-driver.js.map

package/dist/api/reference/stores/postgres.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Postgres-backed storage for the reference backend.
+ *
+ * Present because Postgres disagrees with SQLite in exactly the places API contracts are
+ * ambiguous, which makes the pair a differential oracle rather than a redundant one:
+ *
+ *   - Types are enforced, so a value is stored as its declared type, not by affinity.
+ *   - Collation is locale-aware, so ordering of unicode and mixed case is a real decision.
+ *   - `LIKE` and `ILIKE` are genuinely different operators rather than one with a pragma.
+ *
+ * Each server instance gets its own scratch database, dropped on close, so runs never collide.
+ */
+import postgres from "postgres";
+import type { DefectSet } from "../defects/defect-set.ts";
+import type { EntityDef } from "../model/types.ts";
+import type { SelectPlan } from "../query-types.ts";
+import type { Row, Store } from "../store-api.ts";
+import { type SqlParam } from "./sql-compile.ts";
+/** What the store needs of a Postgres connection. postgres.js's client is one; a test passes its own. */
+export interface PgConnection {
+    unsafe(query: string, args?: SqlParam[]): PromiseLike<readonly Row[]>;
+    end(options: {
+        timeout: number;
+    }): Promise<void>;
+}
+/** Opens a connection pool of at most `max` sessions to one database. */
+export type PgConnect = (database: string, max: number) => PgConnection;
+/** The real driver: postgres.js against the server the environment names, its notices silenced. */
+export declare function connectPostgres(database: string, max: number): ReturnType<typeof postgres>;
+export declare class PgStore implements Store {
+    private readonly flavor;
+    private readonly sql;
+    private readonly admin;
+    private readonly dbName;
+    private readonly defects;
+    private readonly entities;
+    private constructor();
+    static create(defects: DefectSet, entities?: readonly EntityDef[], connect?: PgConnect): Promise<PgStore>;
+    close(): Promise<void>;
+    private migrate;
+    /** The stored column for a field — diverges from the declared name only under the defect. */
+    private physical;
+    /**
+     * Explicit projection, aliased back to declared names.
+     *
+     * Under COLUMN_NAME_MISMATCH the read asks for a column that does not exist. Postgres errors
+     * outright where SQLite's double-quoted-string fallback silently yields the identifier as a
+     * literal — the same defect, two failure modes, which is the point of running both.
+     */
+    private selectList;
+    insert(entity: EntityDef, record: Row): Promise<Row>;
+    byId(entity: EntityDef, id: string | number): Promise<Row | null>;
+    update(entity: EntityDef, id: string | number, patch: Row): Promise<Row | null>;
+    remove(entity: EntityDef, id: string | number): Promise<void>;
+    select(entity: EntityDef, plan: SelectPlan): Promise<Row[]>;
+    /**
+     * Restores declared shapes. `bigint` arrives as a string from the wire protocol and would
+     * fail its own response schema, and a NULL column must read back as null rather than absent.
+     */
+    private decode;
+}
+//# sourceMappingURL=postgres.d.ts.map