@ultimabase/realtime 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,52 @@
+import { definePlugin } from 'ultimabase';
+import manifest from '../package.json' with { type: 'json' };
+import { Engine } from './engine.js';
+import { ownerOf } from './viewer.js';
+// Each running application's engine, by the context its plugin received.
+const engines = new WeakMap();
+const positive = (name, value) => {
+    if (value === undefined || (Number.isInteger(value) && value > 0))
+        return;
+    throw new Error(`realtime's ${name} must be a positive integer.`);
+};
+const realtimeDefinition = definePlugin({
+    name: 'realtime',
+    manifest,
+    api: (context) => {
+        const { options, identify, logger, models, functions } = context;
+        positive('maxLive', options.maxLive);
+        positive('maxSubscriptions', options.maxSubscriptions);
+        positive('maxConnectionRows', options.maxConnectionRows);
+        positive('refresh', options.refresh);
+        for (const model of models)
+            positive('maxLive', model.with?.maxLive);
+        for (const fn of functions) {
+            positive('debounce', fn.with?.debounce);
+            if (fn.used && !fn.query) {
+                throw new Error(`${ownerOf(fn)} is a mutation: it cannot be live.`);
+            }
+        }
+        const engine = new Engine({
+            models,
+            functions,
+            identify,
+            logger,
+            maxLive: options.maxLive ?? 1000,
+            maxSubscriptions: options.maxSubscriptions ?? 100,
+            maxConnectionRows: options.maxConnectionRows ?? 10_000,
+        }, options.refresh ?? 300_000);
+        engines.set(context, engine);
+        const live = new Set(models.filter(({ used }) => used).map(({ schema }) => schema.name));
+        const followed = new Set(functions.filter(({ used }) => used).map(ownerOf));
+        return {
+            connect: async (request) => engine.connect(request),
+            live: (model) => live.has(model),
+            liveFunction: (name) => followed.has(name),
+        };
+    },
+    changed: (changes, context) => engines.get(context)?.changed(changes),
+    missed: (context) => engines.get(context)?.missed(),
+    stop: async (context) => engines.get(context)?.stop(),
+});
+export const realtime = realtimeDefinition.use;
+export const realtimePlugin = realtimeDefinition.plugin;

package/dist/live.d.ts

@@ -0,0 +1,37 @@
+import type { Caller, Logger, ModelQueries } from 'ultimabase';
+import type { LivePlan } from 'ultimabase/internal';
+import type { Batch } from './changes.ts';
+import type { Loader } from './reads.ts';
+import type { LiveMessage } from './messages.ts';
+export type Spec = {
+    readonly model: string;
+    readonly queries: ModelQueries;
+    /** The read's own `where`, which `totalCount` counts. */
+    readonly where: unknown;
+    /** Its `select`, `include` or `omit`, each level's `id` selected. */
+    readonly shape: {
+        readonly [key: string]: unknown;
+    };
+    readonly totalCount: boolean;
+    readonly row: boolean;
+    readonly send: (message: LiveMessage) => void;
+    readonly logger: Logger;
+};
+export declare class Live {
+    #private;
+    caller: Caller;
+    constructor(spec: Spec, caller: Caller, plan: LivePlan, first: number);
+    get first(): number;
+    /** Reads the window and sends it; a failure closes the read. */
+    start(): Promise<void>;
+    /** Follows `batch`, or reads the window again when changes were missed. */
+    apply(batch: Batch, loader: Loader, missed: boolean): Promise<void>;
+    /** Takes the caller's new plan; a changed one reads the window again. */
+    replan(caller: Caller, plan: LivePlan): Promise<void>;
+    /** Shows `more` rows after the last one. */
+    grow(more: number): Promise<void>;
+    /** Reads the window again and sends it whole. */
+    resend(): Promise<void>;
+    close(): void;
+}
+//# sourceMappingURL=live.d.ts.map

package/dist/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../src/live.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAO,MAAM,YAAY,CAAA;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAWnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAGzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAKhD,MAAM,MAAM,IAAI,GAAG;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;IACnD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAA;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,qBAAa,IAAI;;IAChB,MAAM,EAAE,MAAM,CAAA;IAad,YAAY,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAOpE;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,gEAAgE;IAC1D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAS3B;IAED,2EAA2E;IACrE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAKxE;IAED,yEAAyE;IACnE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAY1D;IAED,4CAA4C;IACtC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtC;IAED,iDAAiD;IAC3C,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAG5B;IAED,KAAK,IAAI,IAAI,CAGZ;CAsQD"}

package/dist/live.js

@@ -0,0 +1,309 @@
+import { inMemory, liveSchema, matches, servedRows, sortKeys, storedRows, } from 'ultimabase/internal';
+import { affected } from './affected.js';
+import { reachOf } from './reach.js';
+import { finderOf, pass } from './reads.js';
+import { Window } from './window.js';
+import { Tracking } from './tracking.js';
+export class Live {
+    caller;
+    #plan;
+    #reach;
+    #window;
+    #spec;
+    #find;
+    #tracking = new Tracking();
+    #count;
+    #hasMore = false;
+    #revision = 0;
+    #queue = Promise.resolve();
+    #closed = false;
+    constructor(spec, caller, plan, first) {
+        this.#spec = spec;
+        this.caller = caller;
+        this.#plan = plan;
+        this.#reach = reachOf(liveSchema(), spec.model, plan);
+        this.#window = new Window(plan.orderBy, first);
+        this.#find = finderOf(spec.model);
+    }
+    get first() {
+        return this.#window.first;
+    }
+    /** Reads the window and sends it; a failure closes the read. */
+    async start() {
+        const run = this.#reset();
+        this.#queue = run.catch(() => undefined);
+        try {
+            await run;
+        }
+        catch (error) {
+            this.close();
+            throw error;
+        }
+    }
+    /** Follows `batch`, or reads the window again when changes were missed. */
+    async apply(batch, loader, missed) {
+        const [, settled] = this.#enqueue(async () => missed ? this.#reset() : this.#apply(batch, loader));
+        return settled;
+    }
+    /** Takes the caller's new plan; a changed one reads the window again. */
+    async replan(caller, plan) {
+        const [, settled] = this.#enqueue(async () => {
+            const same = JSON.stringify(plan) === JSON.stringify(this.#plan) &&
+                JSON.stringify(caller) === JSON.stringify(this.caller);
+            this.caller = caller;
+            if (same)
+                return;
+            this.#plan = plan;
+            this.#reach = reachOf(liveSchema(), this.#spec.model, plan);
+            await this.#reset();
+        });
+        return settled;
+    }
+    /** Shows `more` rows after the last one. */
+    async grow(more) {
+        const [run] = this.#enqueue(async () => {
+            this.#window.mark();
+            this.#window.first += more;
+            // Sent even when no row follows: the client waits for it.
+            await this.#send(new Set(), new Set(), false, true);
+        });
+        return run;
+    }
+    /** Reads the window again and sends it whole. */
+    async resend() {
+        const [, settled] = this.#enqueue(async () => this.#reset());
+        return settled;
+    }
+    close() {
+        this.#closed = true;
+        this.#tracking.clear();
+    }
+    #enqueue(task) {
+        const run = this.#queue.then(async () => this.#closed ? undefined : task());
+        const settled = run.catch(async (error) => this.#recover(error));
+        this.#queue = settled;
+        return [run, settled];
+    }
+    async #recover(error) {
+        const { logger, model, send } = this.#spec;
+        if (this.#closed)
+            return;
+        logger.error({ err: error }, `A live read of ${model} failed: it reads again.`);
+        try {
+            await this.#reset();
+        }
+        catch (again) {
+            logger.error({ err: again }, `A live read of ${model} failed: it closes.`);
+            this.close();
+            send({ kind: 'closed' });
+        }
+    }
+    #entry(row) {
+        const keys = sortKeys(this.#spec.model, row, this.#plan.orderBy);
+        return { id: row.id, keys };
+    }
+    /**
+     * The stored rows after the window's last, from `where` and in order:
+     * from the flush's read of the read's own filter when its rights, checked
+     * in memory, leave enough.
+     */
+    async #after(take, loader) {
+        const { model } = this.#spec;
+        const { where, filter, rights, orderBy } = this.#plan;
+        const last = this.#window.entries.at(-1);
+        const page = {
+            orderBy,
+            ...(last && { cursor: { id: { equals: last.id } }, skip: 1 }),
+            take,
+        };
+        if (loader !== undefined && inMemory(model, rights)) {
+            const rows = await loader.after(model, {
+                ...(filter && { where: filter }),
+                ...page,
+            });
+            const kept = rows.filter((row) => matches(model, row, rights));
+            if (kept.length >= take || rows.length < take)
+                return kept.slice(0, take);
+        }
+        return storedRows(model, {
+            ...(where && { where }),
+            ...page,
+            fields: orderBy.map(({ field }) => field),
+        });
+    }
+    async #refill(loader) {
+        const missing = this.#window.missing();
+        if (missing <= 0)
+            return;
+        const rows = await this.#after(missing + 1, loader);
+        const entries = rows.slice(0, missing).map((row) => this.#entry(row));
+        this.#window.fill(entries, rows.length > missing);
+    }
+    async #counted() {
+        const { queries, where } = this.#spec;
+        const args = where === undefined ? {} : { where };
+        return queries.count(args, { as: this.caller });
+    }
+    /**
+     * Reads `ids` as the caller into `nodes`, from the rows the flush loaded
+     * if any; returns those it cannot read.
+     */
+    async #read(ids, nodes, loader) {
+        if (ids.length === 0)
+            return [];
+        const { model, queries, shape } = this.#spec;
+        const args = { ...shape, where: { id: { in: ids } } };
+        const found = loader === undefined
+            ? await queries.findMany(args, { as: this.caller })
+            : await servedRows(model, args, this.caller, await loader.load(model, ids));
+        for (const node of found) {
+            nodes.set(node.id, node);
+            this.#tracking.track(node, this.#plan.include);
+        }
+        return ids.filter((id) => !nodes.has(id));
+    }
+    /**
+     * Refills the window and reads the rows it places; a row the caller
+     * cannot read leaves it, `gone`.
+     */
+    async #settle(again, gone, loader) {
+        const nodes = new Map();
+        for (let round = 0; round < 3; round += 1) {
+            await this.#refill(loader);
+            const moves = this.#window.moves(again);
+            const unread = moves.placed.flatMap(({ id }) => nodes.has(id) ? [] : [id]);
+            const missing = await this.#read(unread, nodes, loader);
+            if (missing.length === 0)
+                return { moves, nodes };
+            for (const id of missing) {
+                this.#window.remove(id);
+                gone.add(id);
+            }
+        }
+        throw new Error('The rows the live plan finds are not readable.');
+    }
+    #next() {
+        this.#revision += 1;
+        return this.#revision;
+    }
+    async #reset() {
+        const { model, row, send, totalCount } = this.#spec;
+        const { where, orderBy } = this.#plan;
+        const { first } = this.#window;
+        this.#window = new Window(orderBy, first);
+        this.#tracking.clear();
+        const rows = await storedRows(model, {
+            ...(where && { where }),
+            orderBy,
+            take: first + 2,
+            fields: orderBy.map(({ field }) => field),
+        });
+        const entries = rows.slice(0, first + 1).map((each) => this.#entry(each));
+        this.#window.fill(entries, rows.length > first + 1);
+        const { nodes } = await this.#settle(new Set(), new Set());
+        this.#count = totalCount ? await this.#counted() : undefined;
+        this.#hasMore = this.#window.hasMore();
+        const shown = this.#window.shown().flatMap(({ id }) => nodes.get(id) ?? []);
+        if (this.#closed)
+            return;
+        if (row) {
+            send({ kind: 'row', revision: this.#next(), row: shown[0] ?? null });
+            return;
+        }
+        send({
+            kind: 'reset',
+            revision: this.#next(),
+            rows: shown,
+            hasMore: this.#hasMore,
+            ...(this.#count !== undefined && { totalCount: this.#count }),
+        });
+    }
+    async #apply(batch, loader) {
+        const { model, totalCount } = this.#spec;
+        const window = this.#window;
+        const effect = await affected({
+            model,
+            reach: this.#reach,
+            window: window.ids(),
+            tracked: this.#tracking.tracked,
+            find: this.#find,
+        }, batch);
+        if (effect === 'resync')
+            return this.#reset();
+        const gone = new Set(effect.deleted);
+        const candidates = [...effect.candidates].filter((id) => !gone.has(id));
+        const rows = await loader.load(model, candidates);
+        const kept = await pass(model, rows, this.#plan.where);
+        const inside = window.ids();
+        const leaving = candidates.filter((id) => inside.has(id) && !kept.has(id));
+        const left = new Map(leaving.flatMap((id) => rows.get(id) ?? []).map((row) => [row.id, row]));
+        const readable = await pass(model, left, this.#plan.rights);
+        const recount = totalCount &&
+            (candidates.length > 0 || effect.deleted.size > 0 || effect.beyond);
+        // A write that leaves the window as it was costs no pass over it.
+        const touched = gone.size > 0 ||
+            effect.resend.size > 0 ||
+            kept.size > 0 ||
+            leaving.length > 0;
+        if (!touched && !recount)
+            return;
+        window.mark();
+        for (const id of effect.deleted)
+            window.remove(id);
+        for (const id of leaving) {
+            window.remove(id);
+            if (!readable.has(id))
+                gone.add(id);
+        }
+        for (const id of kept) {
+            const row = rows.get(id);
+            if (row !== undefined)
+                window.place(this.#entry(row));
+        }
+        await this.#send(effect.resend, gone, recount, false, loader);
+    }
+    /** Sends how the rows shown at the mark changed, if they did or `always`. */
+    async #send(again, gone, recount, always = false, loader) {
+        const { row, send } = this.#spec;
+        const { moves, nodes } = await this.#settle(again, gone, loader);
+        for (const id of moves.removed)
+            this.#tracking.untrack(id);
+        let totalCount;
+        if (recount) {
+            const count = await this.#counted();
+            if (count !== this.#count)
+                totalCount = count;
+            this.#count = count;
+        }
+        if (this.#closed)
+            return;
+        if (row) {
+            if (moves.removed.length + moves.placed.length === 0)
+                return;
+            const [entry] = this.#window.shown();
+            const shown = entry === undefined ? null : (nodes.get(entry.id) ?? null);
+            send({ kind: 'row', revision: this.#next(), row: shown });
+            return;
+        }
+        const changes = [
+            ...moves.removed.map((id) => ({ remove: id, gone: gone.has(id) })),
+            ...moves.placed.flatMap(({ id, after }) => {
+                const node = nodes.get(id);
+                return node === undefined ? [] : [{ upsert: node, after }];
+            }),
+        ];
+        const hasMore = this.#window.hasMore();
+        const more = hasMore !== this.#hasMore;
+        this.#hasMore = hasMore;
+        if (changes.length === 0 && !more && totalCount === undefined && !always) {
+            return;
+        }
+        send({
+            kind: 'changes',
+            revision: this.#next(),
+            changes,
+            ...(more && { hasMore }),
+            ...(totalCount !== undefined && { totalCount }),
+        });
+    }
+}

package/dist/messages.d.ts

@@ -0,0 +1,42 @@
+import type { Row } from 'ultimabase';
+/** A row that left the window, `gone` when deleted or no longer readable. */
+export type Removal = {
+    readonly remove: string;
+    readonly gone: boolean;
+};
+/** A row placed after another, first with `after: null`. */
+export type Upsert = {
+    readonly upsert: Row;
+    readonly after: string | null;
+};
+/** What a live read sends; `revision` grows by one per message. */
+export type LiveMessage = {
+    readonly kind: 'reset';
+    readonly revision: number;
+    readonly rows: readonly Row[];
+    readonly hasMore: boolean;
+    readonly totalCount?: number;
+} | {
+    readonly kind: 'changes';
+    readonly revision: number;
+    readonly changes: readonly (Removal | Upsert)[];
+    /** Only when it changed. */
+    readonly hasMore?: boolean;
+    /** Only when it changed. */
+    readonly totalCount?: number;
+} | {
+    readonly kind: 'row';
+    readonly revision: number;
+    readonly row: Row | null;
+} | {
+    readonly kind: 'value';
+    readonly revision: number;
+    /** A live function's whole result. */
+    readonly value: unknown;
+}
+/** With the error a live function failed with, which closed it. */
+ | {
+    readonly kind: 'closed';
+    readonly error?: unknown;
+};
+//# sourceMappingURL=messages.d.ts.map

package/dist/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAErC,6EAA6E;AAC7E,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAA;AACzE,4DAA4D;AAC5D,MAAM,MAAM,MAAM,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAE5E,mEAAmE;AACnE,MAAM,MAAM,WAAW,GACpB;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC3B,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EAAE,CAAA;IAC/C,4BAA4B;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,4BAA4B;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC3B,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAAA;CACvB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACtB;AACH,mEAAmE;GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA"}

package/dist/messages.js

@@ -0,0 +1 @@
+export {};

package/dist/reach.d.ts

@@ -0,0 +1,57 @@
+import type { Filter, Schema, SchemaField } from 'ultimabase';
+import type { Fields } from './changes.ts';
+import type { LivePlan } from 'ultimabase/internal';
+/** A relation followed from one model to the next. */
+export type Step = {
+    readonly relation: string;
+    readonly many: boolean;
+    readonly target: string;
+    readonly inverse: string;
+    /** The target stores the key: a link changes there, out of sight. */
+    readonly keyOnTarget: boolean;
+};
+/** A level of a filter: its rows are those its steps reach from the root. */
+export type Level = {
+    readonly steps: readonly Step[];
+    readonly model: string;
+    /** The fields it reads, the key back to the level above included. */
+    readonly fields: Fields;
+    /** Under `NOT`, `isNot`, `every`, `none` or `is: null`: a lost link may add a row. */
+    readonly negative: boolean;
+};
+/** A relation the selection shows, or counts. */
+export type Shown = {
+    /** The relations from the root, joined by dots. */
+    readonly path: string;
+    readonly steps: readonly Step[];
+    readonly model: string;
+    /** The fields of its rows that show, or decide which rows show. */
+    readonly fields: Fields;
+    /** A `_count`: its rows are not in the result to track. */
+    readonly counted: boolean;
+};
+export type Reach = {
+    /** The filter's levels, the root's first. */
+    readonly levels: readonly Level[];
+    /** The fields that place a root row: its filter's and its order's. */
+    readonly placing: Fields;
+    /** The root fields that show. */
+    readonly showing: Fields;
+    readonly shown: readonly Shown[];
+    /** Models a nested filter or order reaches further: any change resends all. */
+    readonly deep: ReadonlySet<string>;
+};
+type Models = ReadonlyMap<string, ReadonlyMap<string, SchemaField>>;
+/** `schema`'s fields by model and name. */
+export declare function modelsOf(schema: Schema): Models;
+/** The relation `name` of `model`, if it is one. */
+export declare function stepOf(models: Models, model: string, name: string): Step | undefined;
+/**
+ * Adds the levels of `filter`, read on `model`'s rows, to `levels`; returns
+ * the fields it reads on them.
+ */
+export declare function walk(models: Models, model: string, filter: Filter | undefined, steps: readonly Step[], negative: boolean, levels: Level[]): Fields;
+/** Where `plan`, a live read of `model`, reaches. */
+export declare function reachOf(schema: Schema, model: string, plan: LivePlan): Reach;
+export {};
+//# sourceMappingURL=reach.d.ts.map

package/dist/reach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reach.d.ts","sourceRoot":"","sources":["../src/reach.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAa,MAAM,EAAU,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAChF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,sDAAsD;AACtD,MAAM,MAAM,IAAI,GAAG;IAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,qEAAqE;IACrE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,6EAA6E;AAC7E,MAAM,MAAM,KAAK,GAAG;IACnB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,iDAAiD;AACjD,MAAM,MAAM,KAAK,GAAG;IACnB,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,KAAK,GAAG;IACnB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAA;IACjC,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,CAAA;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAClC,CAAA;AAED,KAAK,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAA;AAInE,2CAA2C;AAC3C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAW/C;AAED,oDAAoD;AACpD,wBAAgB,MAAM,CACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACV,IAAI,GAAG,SAAS,CAWlB;AAWD;;;GAGG;AACH,wBAAgB,IAAI,CACnB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,KAAK,EAAE,GACb,MAAM,CAgCR;AA6FD,qDAAqD;AACrD,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,KAAK,CAgB5E"}

package/dist/reach.js

@@ -0,0 +1,154 @@
+const indexes = new WeakMap();
+/** `schema`'s fields by model and name. */
+export function modelsOf(schema) {
+    const known = indexes.get(schema);
+    if (known !== undefined)
+        return known;
+    const models = new Map(schema.models.map(({ name, fields }) => [
+        name,
+        new Map(fields.map((field) => [field.name, field])),
+    ]));
+    indexes.set(schema, models);
+    return models;
+}
+/** The relation `name` of `model`, if it is one. */
+export function stepOf(models, model, name) {
+    const field = models.get(model)?.get(name);
+    if (field === undefined || field.kind === 'scalar')
+        return undefined;
+    const back = models.get(field.target)?.get(field.inverse);
+    return {
+        relation: name,
+        many: field.kind === 'many',
+        target: field.target,
+        inverse: field.inverse,
+        keyOnTarget: back?.kind === 'one' && back.stored,
+    };
+}
+const relationKeys = ['is', 'isNot', 'some', 'every', 'none'];
+const isList = (value) => Array.isArray(value);
+/**
+ * Adds the levels of `filter`, read on `model`'s rows, to `levels`; returns
+ * the fields it reads on them.
+ */
+export function walk(models, model, filter, steps, negative, levels) {
+    const fields = new Set();
+    const back = steps.at(-1);
+    if (back !== undefined)
+        fields.add(back.inverse);
+    let all = false;
+    const visit = (part, under) => {
+        for (const [key, value] of Object.entries(part ?? {})) {
+            if (value === undefined)
+                continue;
+            if (isList(value)) {
+                for (const inner of value)
+                    visit(inner, under || key === 'NOT');
+                continue;
+            }
+            if (key === '_search')
+                all = true;
+            fields.add(key);
+            const step = stepOf(models, model, key);
+            if (step === undefined)
+                continue;
+            for (const condition of relationKeys) {
+                const inner = value[condition];
+                if (inner === undefined)
+                    continue;
+                const lost = condition === 'is'
+                    ? inner === null
+                    : condition !== 'some' && !(condition === 'isNot' && inner === null);
+                const next = [...steps, step];
+                walk(models, step.target, inner ?? {}, next, under || lost, levels);
+            }
+        }
+    };
+    visit(filter, negative);
+    const read = all ? 'all' : fields;
+    levels.push({ steps, model, fields: read, negative });
+    return read;
+}
+/** The fields a nested read shows: `'all'` when it lists none. */
+function showing(nested, also = []) {
+    if (nested.fields === undefined)
+        return 'all';
+    return new Set([
+        ...nested.fields,
+        ...Object.keys(nested.include ?? {}),
+        ...Object.keys(nested.count ?? {}),
+        ...also,
+    ]);
+}
+const union = (a, b) => a === 'all' || b === 'all' ? 'all' : new Set([...a, ...b]);
+/** The models a nested filter or order reaches beyond `model`. */
+function further(models, model, where, orderBy, deep) {
+    const levels = [];
+    const fields = walk(models, model, where, [], false, levels);
+    for (const level of levels) {
+        if (level.steps.length > 0)
+            deep.add(level.model);
+    }
+    for (const order of orderBy ?? []) {
+        let on = model;
+        for (const { relation } of order.through ?? []) {
+            on = stepOf(models, on, relation)?.target ?? on;
+            deep.add(on);
+        }
+        const counted = order.count && stepOf(models, on, order.field);
+        if (counted)
+            deep.add(counted.target);
+    }
+    return fields;
+}
+/** Adds what `nested`, read on `model`'s rows at `path`, shows. */
+function walkShown(models, model, nested, at, shown, deep) {
+    const named = (name) => (at.path ? `${at.path}.${name}` : name);
+    for (const [name, inner] of Object.entries(nested.include ?? {})) {
+        const step = stepOf(models, model, name);
+        if (step === undefined)
+            continue;
+        const steps = [...at.steps, step];
+        const filtered = further(models, step.target, inner.where, inner.orderBy, deep);
+        const fields = union(showing(inner, [step.inverse]), filtered);
+        shown.push({
+            path: named(name),
+            steps,
+            model: step.target,
+            fields,
+            counted: false,
+        });
+        walkShown(models, step.target, inner, { path: named(name), steps }, shown, deep);
+    }
+    for (const [name, where] of Object.entries(nested.count ?? {})) {
+        const step = stepOf(models, model, name);
+        if (step === undefined)
+            continue;
+        const filtered = further(models, step.target, where, undefined, deep);
+        shown.push({
+            path: named(`_count.${name}`),
+            steps: [...at.steps, step],
+            model: step.target,
+            fields: union(new Set([step.inverse]), filtered),
+            counted: true,
+        });
+    }
+}
+/** Where `plan`, a live read of `model`, reaches. */
+export function reachOf(schema, model, plan) {
+    const models = modelsOf(schema);
+    const levels = [];
+    const root = walk(models, model, plan.where, [], false, levels);
+    levels.reverse();
+    const order = new Set(plan.orderBy.map(({ field }) => field));
+    const shown = [];
+    const deep = new Set();
+    walkShown(models, model, plan, { path: '', steps: [] }, shown, deep);
+    return {
+        levels,
+        placing: union(root, order),
+        showing: showing(plan),
+        shown,
+        deep,
+    };
+}