@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/core/page/memory-reader.js

@@ -0,0 +1,299 @@
+/**
+ * A page's `db` over rows a test gives (the runtime's page unit tests, `testing.ts`): the same reads the
+ * platform's reader (services `slot/page/records.ts`) answers from the database, answered from memory.
+ * What a where, orderBy, paging, include and select mean, and which reads are refused, is the shared
+ * `records-query.ts`; only where the candidate rows come from differs (every row of the table the test
+ * gave, in the order it gave them). Two things it does not do: limits on bytes and rows read (a test's
+ * data is small), and putting a phone operand in stored form (write test data and where values in
+ * E.164, `+14155550123`).
+ */
+import { parentOf, SESSION_TABLE } from '../slot/company-metadata.js';
+import { getCompiledTable, getTableField, relationsOf } from '../slot/compile-schema.js';
+import { emptyFieldValue, makeFieldValue } from '../slot/field.js';
+import { slotFieldNames } from '../slot/row.js';
+import { afterOf, checkListSizes, findAnchors, isPlainObject, limitExceeded, matches, optionalCount, orderKeys, orderRows, pageRows, RECORDS_LIMITS, RecordsQueryError, refuseSearch, relatedKey, relationFilters, RELATION_INCLUDE_KEYS, selectFields, toSlot, unstartableWhy, wayBackFilters, } from './records-query.js';
+const SLOT_STATES = ['filled', 'empty', 'asked_unknown', 'declined'];
+/** A field given as `{ $slot: { value, state, reason } }`, or null for a plain value. */
+function slotGiven(value) {
+    if (!isPlainObject(value) || !('$slot' in value))
+        return null;
+    const slot = value.$slot;
+    if (!isPlainObject(slot) || !SLOT_STATES.includes(slot.state)) {
+        throw new Error(`renderPage: a $slot is { value, state, reason } with state one of ${SLOT_STATES.join(', ')}`);
+    }
+    return slot;
+}
+export function createMemoryReader(input) {
+    const { schema, rows: given, now } = input;
+    const read = new Map();
+    const truth = new Map();
+    const parents = new Map();
+    const calls = [];
+    const tableOf = (name) => {
+        if (name === SESSION_TABLE)
+            throw new RecordsQueryError(`records.${name}: the session is ctx.session, not a table`);
+        const table = getCompiledTable(schema, name);
+        if (!table)
+            throw new RecordsQueryError(`records.${name}: no such table in this sequence`);
+        return table;
+    };
+    // The test's data is checked whole, up front: a mistake in a row the page never reads still shows.
+    for (const [name, rows] of Object.entries(given)) {
+        const table = getCompiledTable(schema, name);
+        if (!table)
+            throw new Error(`renderPage: data.${name}: no such table in the company schema`);
+        for (const row of rows) {
+            if (typeof row.id !== 'string' || !row.id)
+                throw new Error(`renderPage: data.${name}: every row needs a string id`);
+            for (const key of Object.keys(row)) {
+                if (key !== 'id' && key !== 'createdAt' && key !== 'updatedAt' && !getTableField(table, key)) {
+                    throw new Error(`renderPage: data.${name} row ${row.id}: ${key} is not a field of ${name}`);
+                }
+            }
+        }
+    }
+    const relationOf = (tableName, name) => relationsOf(schema, tableName).find((r) => r.name === name);
+    /** A given row as `db` hands it out: each schema field a slot, filled when the test gave a value. */
+    const toRowOut = (tableName, data) => {
+        const table = tableOf(tableName);
+        const id = String(data.id);
+        const out = { id };
+        for (const key of ['createdAt', 'updatedAt'])
+            if (typeof data[key] === 'string')
+                out[key] = data[key];
+        for (const field of slotFieldNames(table.fields)) {
+            const value = data[field];
+            const slot = slotGiven(value);
+            const fv = slot
+                ? makeFieldValue({ value: (slot.value ?? null), state: slot.state, reason: slot.reason ?? null, updatedAt: now })
+                : value === undefined || value === null
+                    ? emptyFieldValue(now)
+                    : makeFieldValue({ value: value, state: 'filled', updatedAt: now });
+            out[field] = toSlot(tableName, id, field, fv);
+        }
+        if (!read.has(id))
+            read.set(id, { table: tableName });
+        truth.set(id, out);
+        return out;
+    };
+    const allRows = (tableName) => (given[tableName] ?? []).map((data) => toRowOut(tableName, data));
+    const noteParents = (tableName, table, field, ids) => {
+        if (parentOf(table)?.field !== field)
+            return;
+        const set = parents.get(tableName) ?? new Set();
+        for (const id of ids)
+            set.add(id);
+        parents.set(tableName, set);
+    };
+    /** The rows of a way back for each parent, in the order the test gave them. */
+    const childrenOf = (relation, parentIds) => {
+        const children = allRows(relation.table);
+        const out = new Map();
+        for (const id of parentIds)
+            out.set(id, children.filter((child) => child[relation.field].value === id));
+        return out;
+    };
+    const filterRows = (tableName, rows, where) => {
+        const table = tableOf(tableName);
+        const relations = relationFilters(table, where);
+        const ways = wayBackFilters(tableName, where, relationOf);
+        const nested = (target, sub) => sub.some((w) => isPlainObject(w) && (relationFilters(tableOf(target), w).length > 0 || wayBackFilters(target, w, relationOf).length > 0));
+        for (const { field, target, sub } of relations) {
+            if (nested(target, sub)) {
+                throw new RecordsQueryError(`records.${tableName}: where.${field}.is filters one level only; read the related rows first, then filter by their ids (in)`);
+            }
+        }
+        for (const { relation, sub } of ways) {
+            if (nested(relation.table, sub)) {
+                throw new RecordsQueryError(`records.${tableName}: where.${relation.name} filters one level only; read those rows first, then filter by their ids (in)`);
+            }
+        }
+        const targets = new Map();
+        for (const { target } of relations)
+            for (const row of allRows(target))
+                targets.set(row.id, row);
+        const related = new Map();
+        for (const { relation } of ways) {
+            const key = relatedKey(tableName, relation.name);
+            if (!related.has(key))
+                related.set(key, childrenOf(relation, rows.map((row) => row.id)));
+        }
+        const context = { schema, targets, related, relationOf };
+        return rows.filter((row) => matches(context, tableName, row, where));
+    };
+    const includeRelation = (tableName, rows, relation, spec, depth) => {
+        const options = isPlainObject(spec) ? spec : {};
+        for (const key of Object.keys(options)) {
+            if (!RELATION_INCLUDE_KEYS.has(key)) {
+                throw new RecordsQueryError(`records.${tableName}: include.${relation.name}.${key} is not supported (where, orderBy, skip, take, include)`);
+            }
+        }
+        if (options.where !== undefined)
+            refuseSearch(relation.table, options.where, `include.${relation.name}.where`);
+        const children = childrenOf(relation, rows.map((row) => row.id));
+        const all = [...children.values()].flat();
+        const kept = options.where === undefined ? null : new Set(filterRows(relation.table, all, options.where).map((row) => row.id));
+        const childTable = tableOf(relation.table);
+        const skip = optionalCount(options.skip, `include.${relation.name}.skip`) ?? 0;
+        const take = optionalCount(options.take, `include.${relation.name}.take`);
+        const shown = [];
+        for (const row of rows) {
+            let list = (children.get(row.id) ?? []).filter((child) => !kept || kept.has(child.id));
+            list = orderRows(orderKeys(childTable, options.orderBy), list).slice(skip, take === undefined ? undefined : skip + take);
+            row[relation.name] = list;
+            shown.push(...list);
+        }
+        include(relation.table, shown, options.include, depth + 1);
+    };
+    const include = (tableName, rows, spec, depth) => {
+        if (spec === undefined || spec === null || spec === false)
+            return;
+        if (!isPlainObject(spec))
+            throw new RecordsQueryError(`records.${tableName}: include must be an object`);
+        if (depth > RECORDS_LIMITS.includeDepth)
+            throw limitExceeded(`records.${tableName}: include goes deeper than ${RECORDS_LIMITS.includeDepth} levels`);
+        const table = tableOf(tableName);
+        for (const [field, nested] of Object.entries(spec)) {
+            if (nested === false || nested === undefined)
+                continue;
+            const ref = getTableField(table, field)?.ref;
+            if (!ref) {
+                const relation = relationOf(tableName, field);
+                if (relation) {
+                    includeRelation(tableName, rows, relation, nested, depth);
+                    continue;
+                }
+                throw new RecordsQueryError(`records.${tableName}: include.${field} is not a lookup nor a way back (relatedName) of ${tableName}`);
+            }
+            if (ref.kind !== 'lookup')
+                throw new RecordsQueryError(`records.${tableName}: include.${field} is the parent; read the parent by id`);
+            tableOf(ref.table);
+            const byId = new Map(allRows(ref.table).map((row) => [row.id, row]));
+            const nestedInclude = isPlainObject(nested) ? nested.include : undefined;
+            include(ref.table, [...byId.values()], nestedInclude, depth + 1);
+            for (const row of rows) {
+                const slot = row[field];
+                slot.row = typeof slot.value === 'string' ? (byId.get(slot.value) ?? null) : null;
+            }
+        }
+    };
+    /** The where as the platform takes it: an email operand lower-cased, as it is stored. */
+    const normalizeWhere = (table, where) => {
+        const out = {};
+        for (const [field, cond] of Object.entries(where)) {
+            if (field === 'AND' || field === 'OR' || field === 'NOT') {
+                out[field] = Array.isArray(cond) ? cond.map((part) => (isPlainObject(part) ? normalizeWhere(table, part) : part)) : isPlainObject(cond) ? normalizeWhere(table, cond) : cond;
+                continue;
+            }
+            const def = Object.hasOwn(table.fields, field) ? table.fields[field] : undefined;
+            out[field] = def?.dataType === 'email' ? lowerEmail(cond) : cond;
+        }
+        return out;
+    };
+    const findMany = (tableName, args) => {
+        const table = tableOf(tableName);
+        const where = normalizeWhere(table, (args.where ?? {}));
+        refuseSearch(tableName, where);
+        checkListSizes(tableName, where);
+        const keys = orderKeys(table, args.orderBy);
+        const place = afterOf(tableName, keys, args);
+        const anchors = findAnchors(table, where);
+        if (anchors.length === 0) {
+            const why = unstartableWhy(tableName, table, where);
+            if (why)
+                throw new RecordsQueryError(why);
+        }
+        else {
+            noteParents(tableName, table, anchors[0].field, anchors[0].ids);
+        }
+        let rows = filterRows(tableName, allRows(tableName), where);
+        rows = orderRows(keys, rows);
+        rows = pageRows(keys, rows, place, args);
+        include(tableName, rows, args.include, 1);
+        return rows.map((row) => selectFields(tableName, table, row, args.select));
+    };
+    const run = (call) => {
+        calls.push(call);
+        const args = (call.args ?? {});
+        if (!isPlainObject(args))
+            throw new RecordsQueryError(`records.${call.table}.${call.method}: arguments must be an object`);
+        switch (call.method) {
+            case 'findMany':
+                return findMany(call.table, args);
+            case 'findFirst':
+                return findMany(call.table, { ...args, take: 1 })[0] ?? null;
+            case 'findUnique': {
+                const where = (args.where ?? {});
+                const keys = Object.keys(where);
+                if (keys.length !== 1 || keys[0] !== 'id' || typeof where.id !== 'string') {
+                    throw new RecordsQueryError(`records.${call.table}.findUnique: where is { id }`);
+                }
+                return findMany(call.table, { ...args, take: 1 })[0] ?? null;
+            }
+            case 'count':
+                return findMany(call.table, { where: args.where, take: RECORDS_LIMITS.rowsPerCall }).length;
+            default:
+                throw new RecordsQueryError(`records.${call.table}: no method ${String(call.method)} (records is read-only)`);
+        }
+    };
+    return {
+        calls,
+        async execute(batch) {
+            return batch.map((call) => {
+                try {
+                    return { ok: true, value: run(call) };
+                }
+                catch (error) {
+                    if (error instanceof RecordsQueryError)
+                        return { ok: false, error: error.message, code: error.code };
+                    throw error;
+                }
+            });
+        },
+        row(tableName, id) {
+            tableOf(tableName);
+            const data = (given[tableName] ?? []).find((row) => String(row.id) === id);
+            return data ? toRowOut(tableName, data) : null;
+        },
+        rowInfo(id) {
+            const seen = read.get(id);
+            const row = truth.get(id);
+            if (!seen || !row)
+                return undefined;
+            const slots = {};
+            for (const [field, slot] of Object.entries(row)) {
+                if (!slot || typeof slot !== 'object' || Array.isArray(slot))
+                    continue;
+                const { value, state, reason, updatedAt } = slot;
+                slots[field] = { value, state, reason, updatedAt };
+            }
+            return { table: seen.table, slots };
+        },
+        parentsOf(table) {
+            return [...(parents.get(table) ?? [])];
+        },
+        adoptRow(table, row) {
+            read.set(row.id, { table });
+            truth.set(row.id, row);
+        },
+    };
+}
+function lowerEmail(cond) {
+    if (typeof cond === 'string')
+        return cond.trim().toLowerCase();
+    if (!isPlainObject(cond))
+        return cond;
+    const out = {};
+    for (const [op, operand] of Object.entries(cond)) {
+        if (op === 'equals' || op === 'startsWith')
+            out[op] = typeof operand === 'string' ? operand.trim().toLowerCase() : operand;
+        else if (op === 'in' || op === 'notIn')
+            out[op] = Array.isArray(operand) ? operand.map((v) => (typeof v === 'string' ? v.trim().toLowerCase() : v)) : operand;
+        else if (op === 'not')
+            out[op] = lowerEmail(operand);
+        else
+            out[op] = operand;
+    }
+    return out;
+}
+//# sourceMappingURL=memory-reader.js.map

package/dist/core/page/page-host.d.ts

@@ -0,0 +1,20 @@
+import type { HostResult } from './sandbox.js';
+/** The zone a page reads time in when the contact gives none. */
+export declare const DEFAULT_PAGE_ZONE = "America/New_York";
+/** A row as `db` hands it out, as far as its time zone goes: each field a slot with a `value`. */
+type CallerRow = Record<string, unknown> | null;
+/** The contact's zone (their `timezone`, else from postal code, state or phone) and today there (25 §11). */
+export declare function timeOfCaller(caller: CallerRow, now: Date): {
+    zone: string;
+    today: string;
+};
+/** `ctx.time.format` (25 §11). */
+export declare function timeCall(args: unknown[]): HostResult;
+/** `ctx.time.day` (25 §11). */
+export declare function dayCall(args: unknown[]): HostResult;
+/** `ctx.time.at` (74 §4.7): a day and a wall time in a zone, as an instant. */
+export declare function atCall(args: unknown[]): HostResult;
+/** `ctx.time.parts` (74 §4.7): an instant's wall-clock parts in a zone. */
+export declare function partsCall(args: unknown[]): HostResult;
+export {};
+//# sourceMappingURL=page-host.d.ts.map

package/dist/core/page/page-host.js

@@ -0,0 +1,57 @@
+/**
+ * The page script's host calls that read no data (25 §11, 74 §4.7): `ctx.time.format`, `.day`, `.at` and `.parts`, done
+ * outside the sandbox where `Intl` is, and the caller's zone and today. The platform's render and the
+ * runtime's page unit tests answer them with these.
+ */
+import { contactTimezone } from '../slot/contact-timezone.js';
+import { dayIn, formatTime, timeAt, timeParts } from './time-format.js';
+/** The zone a page reads time in when the contact gives none. */
+export const DEFAULT_PAGE_ZONE = 'America/New_York';
+/** The contact's zone (their `timezone`, else from postal code, state or phone) and today there (25 §11). */
+export function timeOfCaller(caller, now) {
+    const value = (name) => caller?.[name]?.value;
+    const zone = contactTimezone({ timezone: value('timezone'), postal_code: value('postal_code'), state: value('state'), country: value('country'), phone: value('phone') }, DEFAULT_PAGE_ZONE).timezone;
+    return { zone, today: dayIn(now, zone) };
+}
+/** `ctx.time.format` (25 §11). */
+export function timeCall(args) {
+    const [at, options] = args;
+    try {
+        if (typeof at !== 'string' && typeof at !== 'number')
+            throw new Error('time.format: give an ISO time');
+        return { ok: true, value: formatTime(at, { timeZone: String(options?.timeZone ?? DEFAULT_PAGE_ZONE), ...(options?.style ? { style: options.style } : {}) }) };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** `ctx.time.day` (25 §11). */
+export function dayCall(args) {
+    const [at, timeZone] = args;
+    try {
+        if (typeof at !== 'string' && typeof at !== 'number')
+            throw new Error('time.day: give an ISO time');
+        return { ok: true, value: dayIn(at, String(timeZone ?? DEFAULT_PAGE_ZONE)) };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** `ctx.time.at` / `ctx.time.parts` (74 §4.7). */
+function hostTime(work) {
+    try {
+        return { ok: true, value: work() };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** `ctx.time.at` (74 §4.7): a day and a wall time in a zone, as an instant. */
+export function atCall(args) {
+    return hostTime(() => timeAt(String(args[0]), String(args[1]), String(args[2] ?? DEFAULT_PAGE_ZONE)));
+}
+/** `ctx.time.parts` (74 §4.7): an instant's wall-clock parts in a zone. */
+export function partsCall(args) {
+    return hostTime(() => timeParts(args[0], String(args[1] ?? DEFAULT_PAGE_ZONE)));
+}
+//# sourceMappingURL=page-host.js.map

package/dist/core/page/records-query.d.ts

@@ -0,0 +1,234 @@
+/**
+ * What a `db` read means, apart from where its rows are stored (15 §10.4, 18-record-search-index): the
+ * rows a page script and `ctx.api.db` see (`RowOut`, one `SlotOut` per field), what a `where`,
+ * `orderBy`, `after` / `skip` / `take` and `select` do to them, what a read may not say, and which of its
+ * conditions an index answers. The platform's reader (services `slot/page/records.ts`) loads its
+ * candidate rows from the database and applies these; the runtime's page unit tests
+ * (`testing.ts`) load them from the test's data and apply the same functions.
+ */
+import { type TableRelation } from '../slot/compile-schema.js';
+import { type DataType } from '../slot/schema.js';
+import type { CompiledSlotSchema, FieldValue, RuntimeFieldDef, RuntimeTableDef } from '../slot/types.js';
+export declare const RECORDS_LIMITS: {
+    /** Rows one call may reach through its anchor or the index, before any other filter. */
+    readonly rowsPerCall: 500;
+    /** `findMany` without `take`. */
+    readonly defaultTake: 100;
+    /** `skip`: further on, page with `after`. */
+    readonly maxSkip: 1000;
+    /** Values of one `in` / `notIn`. */
+    readonly listValues: 500;
+    /** `count` counts up to this many; more answer this. */
+    readonly countCap: 10000;
+    /** Rows read by one reader (a page run; one `ctx.api.db` call). */
+    readonly rowsPerRun: 5000;
+    /**
+     * Stored row data (its JSON, UTF-8 bytes) one batch of calls may read (one `ctx.api.db` call, one
+     * sandbox slice), and one reader: what keeps a read from filling this process's memory, checked
+     * before the rows are loaded (34 §8).
+     */
+    readonly bytesPerCall: number;
+    readonly bytesPerRun: number;
+    /** One statement of a read, in milliseconds: past it the read fails as `query_timeout` (34 §8). */
+    readonly statementMs: 3000;
+    readonly includeDepth: 3;
+};
+export type SlotState = FieldValue['state'];
+/** One field as a page script sees it (15 §10.4). */
+export type SlotOut = {
+    value: unknown;
+    state: SlotState;
+    reason: string | null;
+    updatedAt: string | null;
+    ref: {
+        table: string;
+        id: string;
+        field: string;
+    };
+    /** The target row, when the lookup was `include`d. */
+    row?: RowOut | null;
+};
+/**
+ * A row: its id and times (ISO 8601; a stored row's, not the session's), one slot per field, and the
+ * rows of each way back `include`d (`relatedName`).
+ */
+export type RowOut = {
+    id: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [field: string]: SlotOut | RowOut[] | string | undefined;
+};
+export type RecordsMethod = 'findUnique' | 'findFirst' | 'findMany' | 'count';
+export type RecordsCall = {
+    table: string;
+    method: RecordsMethod;
+    args: Record<string, unknown>;
+};
+/** Why a read was refused: a read this API does not take, or one past a limit (18-record-search-index §4.10). */
+export type RecordsQueryErrorCode = 'invalid_read' | 'limit_exceeded';
+export declare class RecordsQueryError extends Error {
+    readonly code: RecordsQueryErrorCode;
+    constructor(message: string, code?: RecordsQueryErrorCode);
+}
+export declare function limitExceeded(message: string): RecordsQueryError;
+export type WhereInput = Record<string, unknown>;
+export type FindArgs = {
+    where?: unknown;
+    include?: unknown;
+    select?: unknown;
+    orderBy?: unknown;
+    take?: unknown;
+    skip?: unknown;
+    /** A row as read: the rows strictly after it in this read's order ({@link afterOf}). */
+    after?: unknown;
+    /** Replaced by `after`: refused, saying so. */
+    cursor?: unknown;
+};
+export declare const COMBINATORS: Set<string>;
+/** Prisma's list filters, on a way back (`relatedName`). */
+export declare const WAY_BACK_FILTERS: Set<string>;
+/** What an `include` of a way back may say of its rows. */
+export declare const RELATION_INCLUDE_KEYS: Set<string>;
+/**
+ * Refuses `contains` / `endsWith` as an operator anywhere in a where (under AND / OR / NOT, a `not`, a
+ * relation's filter), saying what to write instead; before anything is read, whatever path the read
+ * takes. A field may be named `contains`: the where's own keys are fields, only a condition's are
+ * operators.
+ */
+export declare function refuseSearch(tableName: string, where: unknown, path?: string): void;
+/** An anchor: `ids` the field is equal to / in. */
+export type Anchor = {
+    field: string;
+    ids: string[];
+};
+/** The fields of a read's conditions and order that are index entries (not row times): their dictionary ids are needed. */
+export declare function indexedFieldsOf(conditions: readonly IndexCondition[], order: IndexOrder | null | undefined): string[];
+/**
+ * The conditions of a where that pin it to some rows (top level and top-level AND): `id` or a ref
+ * field equal to / in some ids (15 §10.6.1).
+ */
+export declare function findAnchors(table: RuntimeTableDef, where: WhereInput): Anchor[];
+export declare function relationFilters(table: RuntimeTableDef, where: WhereInput): Array<{
+    field: string;
+    target: string;
+    sub: unknown[];
+}>;
+/** What a `where` is judged against beyond the row: `is` targets and the rows of each way back, by parent. */
+export type MatchContext = {
+    schema: CompiledSlotSchema;
+    targets: ReadonlyMap<string, RowOut>;
+    /** `relatedKey(table, relatedName)` → parent id → its rows. */
+    related: ReadonlyMap<string, ReadonlyMap<string, RowOut[]>>;
+    relationOf: (tableName: string, name: string) => TableRelation | undefined;
+};
+/** The ways back a `where` filters by (top level and inside AND / OR / NOT), with their sub-wheres. */
+export declare function wayBackFilters(tableName: string, where: WhereInput, relationOf: MatchContext['relationOf']): Array<{
+    relation: TableRelation;
+    sub: unknown[];
+}>;
+export declare function relatedKey(tableName: string, name: string): string;
+export declare function matches(context: MatchContext, tableName: string, row: RowOut, where: unknown): boolean;
+/**
+ * One key of `orderBy`: the field (a field, `id` or a row time), its direction, how its values compare,
+ * and a field's definition (none for `id` or a row time).
+ */
+export type OrderKey = {
+    field: string;
+    sign: 1 | -1;
+    order: (a: unknown, b: unknown) => number;
+    def?: RuntimeFieldDef;
+};
+export declare function orderKeys(table: RuntimeTableDef, orderBy: unknown): OrderKey[];
+/**
+ * A row's place in a read's order: its value of each order key (null or undefined: none), then its
+ * creation (ms) and id, which break ties.
+ */
+export type Place = {
+    values: unknown[];
+    created: number;
+    id: string;
+};
+/** Rows in the read's order; without keys, as they come (creation order). */
+export declare function orderRows(keys: readonly OrderKey[], rows: RowOut[]): RowOut[];
+/**
+ * `orderBy` as the database can order: null without one, the field when it is one indexed field or a
+ * row time; undefined when it cannot (several keys, `id`, a field not indexed).
+ */
+export declare function indexOrder(table: RuntimeTableDef, orderBy: unknown): IndexOrder | null | undefined;
+/** Rows in the read's order, paged: from strictly after `place`, then `skip`, then `take`. */
+export declare function pageRows(keys: readonly OrderKey[], rows: RowOut[], place: Place | undefined, args: FindArgs): RowOut[];
+/**
+ * `after`: the place a page starts after, read off a row as the reader returned it (normally the last
+ * of the page before). Taken by value, never looked up: its id only breaks ties, so a row since deleted,
+ * changed or of another tenant is only a place and discloses nothing. It needs the row's `id` and
+ * `createdAt`, and its value of each order key: `updatedAt`, or the field's slot (`{ value }`, a null
+ * value for none). A field's value must be of its type ({@link fitsField}): one the index cannot hold
+ * would otherwise place as "no value" in SQL and compare as text in memory.
+ */
+export declare function afterOf(tableName: string, keys: readonly OrderKey[], args: FindArgs): Place | undefined;
+export declare function skipOf(value: unknown): number;
+/** Every `in` / `notIn` of a where (and its AND / OR / NOT, way-back and `is` filters) within `listValues`. */
+export declare function checkListSizes(tableName: string, where: unknown): void;
+export declare function optionalCount(value: unknown, name: string): number | undefined;
+export declare function selectFields(tableName: string, table: RuntimeTableDef, row: RowOut, select: unknown): RowOut;
+export declare function toSlot(table: string, id: string, field: string, value: FieldValue): SlotOut;
+export declare function isUuid(value: unknown): value is string;
+export declare function asArray(value: unknown): unknown[];
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/** A projected field as its schema declares it. */
+export type IndexedField = {
+    dataType: DataType;
+    unique: boolean;
+};
+/** The fields of one table's definition that go to the index. */
+export declare function tableIndexedFields(fields: Record<string, unknown>): Map<string, IndexedField>;
+/** An index entry's typed value columns. */
+export type IndexValue = {
+    valueText: string | null;
+    valueNum: number | null;
+    valueTime: Date | null;
+};
+/** A stored value's index columns; null when it has none to index (empty, or not of its type). */
+export declare function indexValueOf(dataType: DataType, value: unknown): IndexValue | null;
+/**
+ * One condition the database can answer: a field (through the index) or a row time (`row`, a column of
+ * `Record`), its type, and the operators on it.
+ */
+export type IndexCondition = {
+    field: string;
+    dataType: DataType;
+    ops: Record<string, unknown>;
+    insensitive: boolean;
+    row?: true;
+    /** No operators: every row with a value, in its order (a walk along the order, 34 §7). */
+    walk?: true;
+};
+/** The order a read asks for, as the index can order: one field (or a row time) and its direction. */
+export type IndexOrder = {
+    field: string;
+    dataType: DataType;
+    desc: boolean;
+    row?: true;
+};
+/**
+ * The conditions of a where the database can answer (top level and top-level AND): on indexed fields
+ * and row times. And whether they are the whole where (nothing else to check in memory). A condition
+ * on a field that is not indexed, an empty value, `not`, `notIn`, `state`, `OR` and `NOT` are left to
+ * the in-memory filter.
+ */
+export declare function indexConditions(table: RuntimeTableDef, where: WhereInput): {
+    conditions: IndexCondition[];
+    whole: boolean;
+};
+/** The conditions that can start a query; when none can, why. */
+export declare function startableConditions(conditions: readonly IndexCondition[]): {
+    candidates: IndexCondition[];
+    why: string | null;
+};
+/**
+ * Why a `where` with no anchor (`id` or a ref field equal to / in some ids) cannot be read: no condition
+ * on an indexed field or a row time starts it. Null when one does. The platform's reader and the page
+ * unit tests refuse the same reads, with this message.
+ */
+export declare function unstartableWhy(tableName: string, table: RuntimeTableDef, where: WhereInput): string | null;
+//# sourceMappingURL=records-query.d.ts.map