ultimabase 0.0.0-stage → 0.1.0

package/dist/manifest.js

@@ -0,0 +1,60 @@
+// A plugin's manifest (D-57, D-95): checked by `definePlugin`, its ranges
+// matched at `start` against the running kernel and the installed plugins.
+import { satisfies, valid, validRange } from 'semver';
+import kernel from '../package.json' with { type: 'json' };
+import { isObject } from './query-where.js';
+import { Refused } from './errors.js';
+/** Checks a plugin's `manifest`: a name, a version and valid ranges. */
+export function manifestOf(value, plugin) {
+    const path = `${plugin}.manifest`;
+    if (!isObject(value))
+        throw new TypeError(`${path} is an object.`);
+    const { name, version, peerDependencies } = value;
+    if (typeof name !== 'string' || name === '') {
+        throw new TypeError(`${path}.name is a package name.`);
+    }
+    if (typeof version !== 'string' || valid(version) === null) {
+        throw new TypeError(`${path}.version is a version, not ${String(version)}.`);
+    }
+    if (peerDependencies === undefined)
+        return Object.freeze({ name, version });
+    if (!isObject(peerDependencies)) {
+        throw new TypeError(`${path}.peerDependencies is an object.`);
+    }
+    const ranges = {};
+    for (const [peer, range] of Object.entries(peerDependencies)) {
+        if (typeof range !== 'string' || validRange(range) === null) {
+            throw new TypeError(`${path}.peerDependencies.${peer} is a version range, not ${String(range)}.`);
+        }
+        ranges[peer] = range;
+    }
+    return Object.freeze({
+        name,
+        version,
+        peerDependencies: Object.freeze(ranges),
+    });
+}
+// A prerelease of the kernel runs the plugins written for its version range.
+const accepts = (version, range) => satisfies(version, range, { includePrerelease: true });
+/**
+ * Refuses a plugin whose ranges exclude the running kernel or an installed
+ * plugin, naming both versions; warns of one that gives the kernel no range.
+ */
+export function checkVersions(plugins, logger) {
+    const installed = new Map([[kernel.name, kernel.version]]);
+    for (const { code } of plugins) {
+        installed.set(code.manifest.name, code.manifest.version);
+    }
+    for (const { code } of plugins) {
+        const { name, version, peerDependencies = {} } = code.manifest;
+        if (peerDependencies[kernel.name] === undefined) {
+            logger.warn(`${name} declares no ${kernel.name} range.`);
+        }
+        for (const [peer, range] of Object.entries(peerDependencies)) {
+            const found = installed.get(peer);
+            if (found === undefined || accepts(found, range))
+                continue;
+            throw new Refused(`${name} ${version} needs ${peer} ${range}; this is ${peer} ${found}.`);
+        }
+    }
+}

package/dist/memory-aggregate.d.ts

@@ -0,0 +1,7 @@
+import type { AggregateRead, Read } from './adapter.ts';
+import type { Reader, StoredRow } from './memory-read.ts';
+/** Of the rows with the same keys, the first in `read`'s order (D-147). */
+export declare function distinct(reader: Reader, read: Read, rows: StoredRow[]): StoredRow[];
+/** Each group of `rows`: its keys' values, then its aggregates', in order. */
+export declare function grouped(reader: Reader, read: AggregateRead, rows: readonly StoredRow[]): unknown[][];
+//# sourceMappingURL=memory-aggregate.d.ts.map

package/dist/memory-aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-aggregate.d.ts","sourceRoot":"","sources":["../src/memory-aggregate.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEX,aAAa,EAGb,IAAI,EAEJ,MAAM,cAAc,CAAA;AAIrB,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AA0DzD,2EAA2E;AAC3E,wBAAgB,QAAQ,CACvB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,SAAS,EAAE,GACf,SAAS,EAAE,CAeb;AAyBD,8EAA8E;AAC9E,wBAAgB,OAAO,CACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,SAAS,SAAS,EAAE,GACxB,OAAO,EAAE,EAAE,CAqCb"}

package/dist/memory-aggregate.js

@@ -0,0 +1,107 @@
+import { sumDecimals } from './decimal.js';
+import { and, isFilters, not, or, scalar } from './memory-conditions.js';
+import { compareKeys, compareValues, copy, sortable } from './memory-values.js';
+function of(values, operation, field) {
+    if (operation === 'count')
+        return values.length;
+    const [head, ...rest] = values;
+    if (head === undefined)
+        return null;
+    if (operation === 'min' || operation === 'max') {
+        const sign = operation === 'min' ? 1 : -1;
+        const order = (a, b) => compareValues(sortable(a, field), sortable(b, field));
+        const found = rest.reduce((best, item) => (sign * order(item, best) < 0 ? item : best), head);
+        return copy(found);
+    }
+    const sum = field?.kind === 'scalar' && field.type === 'decimal'
+        ? sumDecimals(values.map(String), field.scale ?? 0)
+        : values.reduce((total, item) => total + Number(item), 0);
+    return operation === 'sum' ? sum : Number(sum) / values.length;
+}
+/** One value per aggregate of `rows`, in order. */
+function aggregated(rows, aggregates, fieldOf) {
+    return aggregates.map(({ operation, field }) => {
+        if (field === undefined)
+            return rows.length;
+        const values = rows.map((row) => row[field] ?? null);
+        return of(values.filter((item) => item !== null), operation, fieldOf(field));
+    });
+}
+/** The values of a row's keys, a key through a relation its target's. */
+function keysOf(reader, model, row, by) {
+    return by.map(({ field, through }) => {
+        const reached = reader.reach(model, row, through);
+        return copy(reached?.row[field] ?? null);
+    });
+}
+/** Of the rows with the same keys, the first in `read`'s order (D-147). */
+export function distinct(reader, read, rows) {
+    const { where, orderBy } = read;
+    const sorted = reader.select(read.model, rows, {
+        ...(where && { where }),
+        ...(orderBy && { orderBy }),
+    });
+    const seen = new Set();
+    return sorted.filter((row) => {
+        const id = JSON.stringify(keysOf(reader, read.model, row, read.distinct ?? []));
+        if (seen.has(id))
+            return false;
+        seen.add(id);
+        return true;
+    });
+}
+/** Whether a group's values pass `having`, whose keys are positions (D-149). */
+function held(filter, values, fields) {
+    const truths = [];
+    for (const [key, part] of Object.entries(filter)) {
+        if (part === undefined)
+            continue;
+        if (!isFilters(part)) {
+            const at = Number(key);
+            const sorted = (value) => sortable(value, fields[at]);
+            truths.push(scalar(values[at] ?? null, part, sorted));
+            continue;
+        }
+        const inner = part.map((each) => held(each, values, fields));
+        if (key === 'AND')
+            truths.push(and(inner));
+        else if (key === 'OR')
+            truths.push(or(inner));
+        else
+            truths.push(and(inner.map((truth) => not(truth))));
+    }
+    return and(truths);
+}
+/** Each group of `rows`: its keys' values, then its aggregates', in order. */
+export function grouped(reader, read, rows) {
+    const by = read.by ?? [];
+    const fieldOf = (name) => reader.field(read.model, name);
+    const groups = new Map();
+    if (by.length === 0)
+        groups.set('[]', { keys: [], rows: [] });
+    for (const row of rows) {
+        const keys = keysOf(reader, read.model, row, by);
+        const id = JSON.stringify(keys);
+        const group = groups.get(id) ?? { keys, rows: [] };
+        group.rows.push(row);
+        groups.set(id, group);
+    }
+    const lists = [...groups.values()].map((group) => [
+        ...group.keys,
+        ...aggregated(group.rows, read.aggregates, fieldOf),
+    ]);
+    // A key through a relation is an id; a decimal sorts by value (D-145).
+    const fields = [
+        ...by.map(({ field, through }) => (through ? undefined : field)),
+        ...read.aggregates.map(({ operation, field }) => operation === 'count' ? undefined : field),
+    ].map((name) => (name === undefined ? undefined : fieldOf(name)));
+    const { having } = read;
+    const kept = having === undefined
+        ? lists
+        : lists.filter((list) => held(having, list, fields) === true);
+    const order = read.orderBy ?? [];
+    const sorted = (list) => order.map(({ at }) => sortable(list[at], fields[at]));
+    kept.sort((a, b) => compareKeys(sorted(a), sorted(b), order));
+    const skip = read.skip ?? 0;
+    return kept.slice(skip, read.take === undefined ? undefined : skip + read.take);
+}

package/dist/memory-conditions.d.ts

@@ -0,0 +1,8 @@
+import type { Condition, Filter } from './adapter.ts';
+export type Truth = boolean | null;
+export declare function and(truths: readonly Truth[]): Truth;
+export declare function or(truths: readonly Truth[]): Truth;
+export declare function not(truth: Truth): Truth;
+export declare function isFilters(value: Condition | readonly Filter[]): value is readonly Filter[];
+export declare function scalar(stored: unknown, condition: Condition, sorted: (value: unknown) => unknown): Truth;
+//# sourceMappingURL=memory-conditions.d.ts.map

package/dist/memory-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-conditions.d.ts","sourceRoot":"","sources":["../src/memory-conditions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAIrD,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,IAAI,CAAA;AAElC,wBAAgB,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,CAGnD;AAED,wBAAgB,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,CAGlD;AAED,wBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAEvC;AAED,wBAAgB,SAAS,CACxB,KAAK,EAAE,SAAS,GAAG,SAAS,MAAM,EAAE,GAClC,KAAK,IAAI,SAAS,MAAM,EAAE,CAE5B;AAED,wBAAgB,MAAM,CACrB,MAAM,EAAE,OAAO,EACf,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,GACjC,KAAK,CAuDP"}

package/dist/memory-conditions.js

@@ -0,0 +1,82 @@
+import { jsonPath } from './memory-json.js';
+import { compareValues, lower, same, text } from './memory-values.js';
+export function and(truths) {
+    if (truths.includes(false))
+        return false;
+    return truths.includes(null) ? null : true;
+}
+export function or(truths) {
+    if (truths.includes(true))
+        return true;
+    return truths.includes(null) ? null : false;
+}
+export function not(truth) {
+    return truth === null ? null : !truth;
+}
+export function isFilters(value) {
+    return Array.isArray(value);
+}
+export function scalar(stored, condition, sorted) {
+    if (condition.path !== undefined)
+        return jsonPath(stored, condition);
+    const truths = [];
+    const known = stored !== null;
+    const fold = condition.mode === 'insensitive' ? lower : (item) => item;
+    const value = fold(stored);
+    for (const [operator, raw] of Object.entries(condition)) {
+        if (raw === undefined || operator === 'mode')
+            continue;
+        const operand = Array.isArray(raw)
+            ? raw.map((item) => fold(item))
+            : fold(raw);
+        if (operator === 'equals' || operator === 'not') {
+            const equal = operand === null ? !known : known ? same(value, operand) : null;
+            truths.push(operator === 'equals' ? equal : not(equal));
+        }
+        else if (operator === 'in' || operator === 'notIn') {
+            const list = Array.isArray(operand) ? operand : [];
+            const found = list.length === 0
+                ? false
+                : known
+                    ? list.some((item) => same(value, item))
+                    : null;
+            truths.push(operator === 'in' ? found : not(found));
+        }
+        else if (!known) {
+            truths.push(null);
+        }
+        else if (operator.startsWith('has') || operator === 'isEmpty') {
+            const items = Array.isArray(value) ? value : [];
+            const wanted = Array.isArray(operand)
+                ? operand
+                : [operand];
+            const holds = (item) => items.includes(item);
+            truths.push(operator === 'isEmpty'
+                ? (items.length === 0) === operand
+                : operator === 'hasEvery'
+                    ? wanted.every(holds)
+                    : wanted.some(holds));
+        }
+        else if (operator === 'contains') {
+            truths.push(text(value, operand, (a, b) => a.includes(b)));
+        }
+        else if (operator === 'startsWith') {
+            truths.push(text(value, operand, (a, b) => a.startsWith(b)));
+        }
+        else if (operator === 'endsWith') {
+            truths.push(text(value, operand, (a, b) => a.endsWith(b)));
+        }
+        else {
+            const order = compareValues(sorted(value), sorted(operand));
+            if (operator === 'lt')
+                truths.push(order < 0);
+            else if (operator === 'lte')
+                truths.push(order <= 0);
+            else if (operator === 'gt')
+                truths.push(order > 0);
+            else
+                truths.push(order >= 0);
+        }
+    }
+    return and(truths);
+}

package/dist/memory-draft.d.ts

@@ -0,0 +1,34 @@
+import type { AggregateRead, Changed, CountRead, Read, Row, Schema, Write } from './adapter.ts';
+import type { Fields, Store } from './memory-read.ts';
+import { Reader } from './memory-read.ts';
+export declare class Draft {
+    readonly reader: Reader;
+    readonly schema: Schema;
+    /** What the write changed, in order, for the feed (D-154). */
+    readonly changed: Changed[];
+    constructor(store: Store, fields: Fields, schema: Schema);
+    find(read: Read): Row[];
+    count(read: CountRead): number;
+    aggregate(read: AggregateRead): unknown[][];
+    private selected;
+    write(write: Write): Row[];
+    private change;
+    private note;
+    private matching;
+    private stored;
+    /** The numbers and lists a change computes on `row` (D-132, D-149). */
+    private computed;
+    /** Applies `delete`; returns the ids it removed. */
+    private remove;
+    private apply;
+    private joinFields;
+    private side;
+    private ids;
+    /** Links `id` to `target` unless they were; tells whether it did. */
+    private link;
+    /** Unlinks `id` from `targets`; returns the targets it was linked to. */
+    private unlink;
+    /** Unique fields, unique indexes and one-to-one keys; `null` never clashes. */
+    private checkUnique;
+}
+//# sourceMappingURL=memory-draft.d.ts.map

package/dist/memory-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-draft.d.ts","sourceRoot":"","sources":["../src/memory-draft.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,aAAa,EAGb,OAAO,EACP,SAAS,EAET,IAAI,EACJ,GAAG,EAEH,MAAM,EAEN,KAAK,EACL,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAa,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA4BzC,qBAAa,KAAK;IACjB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,CAAK;IAEhC,YAAY,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAGvD;IAED,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,GAAG,EAAE,CAMtB;IAED,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAE7B;IAED,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,EAAE,EAAE,CAE1C;IAED,OAAO,CAAC,QAAQ;IAOhB,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,GAAG,EAAE,CA4BzB;IAED,OAAO,CAAC,MAAM;IAcd,OAAO,CAAC,IAAI;IAKZ,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,MAAM;IAad,uEAAuE;IACvE,OAAO,CAAC,QAAQ;IAmBhB,oDAAoD;IACpD,OAAO,CAAC,MAAM;IAed,OAAO,CAAC,KAAK;IAuDb,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,IAAI;IAUZ,OAAO,CAAC,GAAG;IAUX,qEAAqE;IACrE,OAAO,CAAC,IAAI;IAaZ,yEAAyE;IACzE,OAAO,CAAC,MAAM;IAcd,+EAA+E;IAC/E,OAAO,CAAC,WAAW;CAqBnB"}

package/dist/memory-draft.js

@@ -0,0 +1,255 @@
+import { CheckFailed, OutOfRange, UniqueViolation } from './adapter.js';
+import { Reader } from './memory-read.js';
+import { distinct, grouped } from './memory-aggregate.js';
+import { copy } from './memory-values.js';
+import { listed } from './list-update.js';
+import { computed } from './number-update.js';
+import { isInteger } from './query-where.js';
+/**
+ * A value as PostgreSQL gives it back: `-0` is `0`, which `pg` sends for a
+ * number, and JSON text for json (D-94).
+ */
+function storedAs(type, value) {
+    if (type === 'json') {
+        const parsed = JSON.parse(JSON.stringify(value));
+        return parsed;
+    }
+    if (type === 'number' && value === 0)
+        return 0;
+    return copy(value);
+}
+function keyOf(values) {
+    return JSON.stringify(values.map((value) => value instanceof Date ? `date:${value.getTime()}` : value));
+}
+export class Draft {
+    reader;
+    schema;
+    /** What the write changed, in order, for the feed (D-154). */
+    changed = [];
+    constructor(store, fields, schema) {
+        this.reader = new Reader(store, fields);
+        this.schema = schema;
+    }
+    find(read) {
+        const stored = [...this.reader.table(read.model).values()];
+        const rows = read.distinct ? distinct(this.reader, read, stored) : stored;
+        return this.reader
+            .select(read.model, rows, read)
+            .map((row) => this.reader.output(read.model, row, read));
+    }
+    count(read) {
+        return this.selected(read).length;
+    }
+    aggregate(read) {
+        return grouped(this.reader, read, this.selected(read));
+    }
+    selected(read) {
+        const rows = [...this.reader.table(read.model).values()];
+        return rows.filter((row) => this.reader.matches(read.model, row, read.where) === true);
+    }
+    write(write) {
+        for (const [index, check] of (write.checks ?? []).entries()) {
+            if (this.count(check) !== check.count)
+                throw new CheckFailed(index);
+        }
+        const read = write.read;
+        if (read !== undefined && write.before === true) {
+            const { model } = read;
+            const deletes = write.changes.some((change) => change.kind === 'delete' && change.model === model);
+            const update = write.changes.find((change) => change.kind === 'update' && change.model === model);
+            if (!deletes) {
+                // The rows its update changed, as it left them (D-133).
+                const changed = update && this.matching(model, update);
+                const ids = new Set(changed?.map((row) => row.id));
+                this.change(write.changes);
+                return this.find(read).filter((row) => ids.has(row.id));
+            }
+            const rows = this.find(read);
+            this.change(write.changes);
+            // The rows the write's delete removed, as they were (D-104).
+            const table = this.reader.table(read.model);
+            return rows.filter((row) => !table.has(row.id));
+        }
+        this.change(write.changes);
+        return read === undefined ? [] : this.find(read);
+    }
+    change(changes) {
+        const touched = new Set();
+        this.reader.removed.clear();
+        for (const [index, change] of changes.entries()) {
+            touched.add(change.model);
+            if (change.kind === 'delete') {
+                const removed = this.remove(change);
+                this.reader.removed.set(index, removed);
+                this.note({ kind: 'delete', model: change.model, ids: [...removed] });
+            }
+            else
+                this.apply(change);
+        }
+        for (const model of touched)
+            this.checkUnique(model);
+    }
+    note(change) {
+        const rows = 'field' in change ? change.pairs : change.ids;
+        if (rows?.length !== 0)
+            this.changed.push(change);
+    }
+    matching(model, change) {
+        if (change.kind !== 'update' && change.kind !== 'delete')
+            return [];
+        return [...this.reader.table(model).values()].filter((row) => this.reader.matches(model, row, change.where) === true);
+    }
+    stored(model, value) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+            const field = this.reader.field(model, key);
+            const type = field?.kind === 'scalar' ? field.type : undefined;
+            return [key, storedAs(type, item)];
+        }));
+    }
+    /** The numbers and lists a change computes on `row` (D-132, D-149). */
+    computed(model, row, compute = {}) {
+        return Object.fromEntries(Object.entries(compute).map(([key, operation]) => {
+            if ('elements' in operation)
+                return [key, listed(row[key], operation)];
+            const field = this.reader.field(model, key);
+            const integer = field?.kind === 'scalar' && field.integer === true;
+            const result = computed(row[key], operation, integer);
+            if (integer ? !isInteger(result) : !Number.isFinite(result)) {
+                throw new OutOfRange(model, key);
+            }
+            return [key, result];
+        }));
+    }
+    /** Applies `delete`; returns the ids it removed. */
+    remove(change) {
+        const table = this.reader.table(change.model);
+        const removed = new Set();
+        for (const row of this.matching(change.model, change)) {
+            removed.add(row.id);
+            table.delete(row.id);
+            for (const field of this.joinFields(change.model)) {
+                this.unlink(change.model, field, row.id, [
+                    ...(this.side(change.model, field.name).get(row.id) ?? []),
+                ]);
+            }
+        }
+        return removed;
+    }
+    apply(change) {
+        const table = this.reader.table(change.model);
+        switch (change.kind) {
+            case 'insert': {
+                if (table.has(change.row.id)) {
+                    throw new UniqueViolation(change.model, ['id']);
+                }
+                table.set(change.row.id, {
+                    ...this.stored(change.model, change.row),
+                    id: change.row.id,
+                });
+                this.note({ kind: 'insert', model: change.model, ids: [change.row.id] });
+                return;
+            }
+            case 'update': {
+                const rows = this.matching(change.model, change);
+                for (const row of rows) {
+                    const set = {
+                        ...change.set,
+                        ...this.computed(change.model, row, change.compute),
+                    };
+                    table.set(row.id, {
+                        ...row,
+                        ...this.stored(change.model, set),
+                        id: row.id,
+                    });
+                }
+                const fields = [
+                    ...Object.keys(change.set),
+                    ...Object.keys(change.compute ?? {}),
+                ];
+                const ids = rows.map((row) => row.id);
+                this.note({ kind: 'update', model: change.model, ids, fields });
+                return;
+            }
+            case 'link':
+            case 'unlink': {
+                const field = this.reader.field(change.model, change.field);
+                if (field?.kind !== 'many' || !field.join) {
+                    throw new Error(`${change.model}.${change.field} has no join.`);
+                }
+                const { model, id } = change;
+                const targets = change.kind === 'unlink'
+                    ? this.unlink(model, field, id, change.targets)
+                    : change.targets.filter((target) => this.link(model, field, id, target));
+                const pairs = targets.map((target) => [id, target]);
+                this.note({ kind: change.kind, model, field: field.name, pairs });
+                return;
+            }
+        }
+    }
+    joinFields(model) {
+        return [...(this.reader.fields.get(model)?.values() ?? [])].filter((field) => field.kind === 'many' && field.join && field.from === undefined);
+    }
+    side(model, field) {
+        const name = `${model}.${field}`;
+        let side = this.reader.store.joins.get(name);
+        if (side === undefined) {
+            side = new Map();
+            this.reader.store.joins.set(name, side);
+        }
+        return side;
+    }
+    ids(model, field, id) {
+        const side = this.side(model, field);
+        let ids = side.get(id);
+        if (ids === undefined) {
+            ids = new Set();
+            side.set(id, ids);
+        }
+        return ids;
+    }
+    /** Links `id` to `target` unless they were; tells whether it did. */
+    link(model, field, id, target) {
+        const ids = this.ids(model, field.name, id);
+        if (ids.has(target))
+            return false;
+        ids.add(target);
+        this.ids(field.target, field.inverse, target).add(id);
+        return true;
+    }
+    /** Unlinks `id` from `targets`; returns the targets it was linked to. */
+    unlink(model, field, id, targets) {
+        if (field.kind !== 'many')
+            return [];
+        return targets.filter((target) => {
+            const removed = this.side(model, field.name).get(id)?.delete(target);
+            this.side(field.target, field.inverse).get(target)?.delete(id);
+            return removed === true;
+        });
+    }
+    /** Unique fields, unique indexes and one-to-one keys; `null` never clashes. */
+    checkUnique(model) {
+        const definition = this.schema.models.find((each) => each.name === model);
+        if (definition === undefined)
+            return;
+        const sets = definition.indexes
+            .filter((index) => index.unique)
+            .map((index) => index.fields);
+        for (const field of definition.fields) {
+            if (field.kind !== 'many' && field.unique)
+                sets.push([field.name]);
+        }
+        const rows = [...this.reader.table(model).values()];
+        for (const fields of sets) {
+            const seen = new Set();
+            for (const row of rows) {
+                const values = fields.map((field) => row[field] ?? null);
+                if (values.includes(null))
+                    continue;
+                const found = keyOf(values);
+                if (seen.has(found))
+                    throw new UniqueViolation(model, fields);
+                seen.add(found);
+            }
+        }
+    }
+}

package/dist/memory-json.d.ts

@@ -0,0 +1,6 @@
+import type { Condition } from './adapter.ts';
+type Truth = boolean | null;
+/** A json condition with `path`: unknown where the value lacks the path. */
+export declare function jsonPath(stored: unknown, condition: Condition): Truth;
+export {};
+//# sourceMappingURL=memory-json.d.ts.map

package/dist/memory-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-json.d.ts","sourceRoot":"","sources":["../src/memory-json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAI7C,KAAK,KAAK,GAAG,OAAO,GAAG,IAAI,CAAA;AA2C3B,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,KAAK,CAwCrE"}

package/dist/memory-json.js

@@ -0,0 +1,86 @@
+import { compareValues, lower, same, text } from './memory-values.js';
+import { isObject } from './query-where.js';
+/** An array's index as PostgreSQL's `strtoint` reads it; `undefined` when not one. */
+function indexOf(key, length) {
+    if (!/^[\t\n\v\f\r ]*[+-]?\d+$/.test(key))
+        return undefined;
+    const index = Number(key);
+    if (index < -2_147_483_647 || index > 2_147_483_647)
+        return undefined;
+    return index < 0 ? length + index : index;
+}
+/** The value at `path`, `undefined` where the value lacks it. */
+function at(value, path) {
+    let current = value;
+    for (const key of path) {
+        if (Array.isArray(current)) {
+            const index = indexOf(key, current.length);
+            current = index === undefined || index < 0 ? undefined : current[index];
+        }
+        else if (isObject(current) && Object.hasOwn(current, key)) {
+            current = current[key];
+        }
+        else
+            return undefined;
+    }
+    return current;
+}
+/** `@>`: a nested value is held only by a value of its own JSON type. */
+function holds(container, item) {
+    if (Array.isArray(container) && Array.isArray(item)) {
+        return item.every((each) => container.some((one) => holds(one, each)));
+    }
+    if (isObject(container) && isObject(item)) {
+        return Object.entries(item).every(([key, each]) => Object.hasOwn(container, key) && holds(container[key], each));
+    }
+    return (!Array.isArray(container) && !isObject(container) && same(container, item));
+}
+const typeOf = (value) => Array.isArray(value) ? 'array' : value === null ? 'null' : typeof value;
+/** A json condition with `path`: unknown where the value lacks the path. */
+export function jsonPath(stored, condition) {
+    const value = stored === null ? undefined : at(stored, condition.path ?? []);
+    if (value === undefined)
+        return null;
+    const fold = condition.mode === 'insensitive' ? lower : (item) => item;
+    const strings = (test, operand) => text(fold(value), fold(operand), test);
+    const items = Array.isArray(value) ? value : [];
+    const truths = [];
+    for (const [operator, operand] of Object.entries(condition)) {
+        if (operand === undefined || operator === 'mode' || operator === 'path')
+            continue;
+        if (operator === 'equals')
+            truths.push(same(value, operand));
+        else if (operator === 'not')
+            truths.push(!same(value, operand));
+        else if (operator === 'stringContains') {
+            truths.push(strings((a, b) => a.includes(b), operand));
+        }
+        else if (operator === 'stringStartsWith') {
+            truths.push(strings((a, b) => a.startsWith(b), operand));
+        }
+        else if (operator === 'stringEndsWith') {
+            truths.push(strings((a, b) => a.endsWith(b), operand));
+        }
+        else if (operator === 'arrayContains') {
+            truths.push(Array.isArray(value) && holds(value, operand));
+        }
+        else if (operator === 'arrayStartsWith') {
+            truths.push(items.length > 0 && same(items[0], operand));
+        }
+        else if (operator === 'arrayEndsWith') {
+            truths.push(items.length > 0 && same(items.at(-1), operand));
+        }
+        else {
+            const order = compareValues(value, operand);
+            const kept = operator === 'lt'
+                ? order < 0
+                : operator === 'lte'
+                    ? order <= 0
+                    : operator === 'gt'
+                        ? order > 0
+                        : order >= 0;
+            truths.push(typeOf(value) === typeOf(operand) && kept);
+        }
+    }
+    return !truths.includes(false);
+}