ultimabase 0.0.0-stage → 0.1.0

package/dist/scope.js

@@ -0,0 +1,82 @@
+import { and } from './access.js';
+import { beforeFind } from './hooks.js';
+import { Relations } from './relations.js';
+import { modelOf } from './query-where.js';
+/**
+ * `readable` is synchronous, as the planning that calls it, but `beforeFind`
+ * may not be: a model read before its hook ran is recorded, and `ready` runs
+ * the hooks so the query can be planned again with their filters.
+ */
+export class QueryScope {
+    /** By `operation name`, as `read Post`. */
+    narrowed = new Map();
+    wanted = new Map();
+    models;
+    caller;
+    /** `undefined` for Master, which skips access rules (D-48). */
+    access;
+    relations;
+    constructor(models, caller, access) {
+        this.models = models;
+        this.caller = caller;
+        this.access = access;
+        this.relations = access?.relations ?? new Relations(models, caller);
+    }
+    check(model, field, path, verb) {
+        this.access?.check(model, field, path, verb);
+    }
+    ruled(model, field) {
+        return this.access?.ruled(model, field) ?? false;
+    }
+    /**
+     * The rows of `name` the query reads, or the write `operation` targets:
+     * its read rule and `beforeFind`.
+     */
+    readable(name, operation = 'read') {
+        return and(this.narrowing(name, operation), this.access?.readable(name));
+    }
+    related(model, field) {
+        return and(this.relations.filter(model, field), this.readable(field.target));
+    }
+    /**
+     * Runs the `beforeFind` hooks of the models read since the last call;
+     * whether one of them narrows, so the query must be planned again.
+     */
+    async ready() {
+        let narrowed = false;
+        for (const [key, { name, operation }] of this.wanted) {
+            this.wanted.delete(key);
+            const model = modelOf(this.models, name);
+            const filter = await beforeFind(this.models, model, this.caller, operation, this.relations);
+            this.narrowed.set(key, filter);
+            if (filter !== undefined)
+                narrowed = true;
+        }
+        return narrowed;
+    }
+    /**
+     * The rows of `name` a write reaches; `trusted` for a value a hook or a
+     * default wrote, which skips access rules but not `beforeFind` (D-67).
+     */
+    async filter(name, trusted, operation = 'read') {
+        this.narrowing(name, operation);
+        await this.ready();
+        return trusted
+            ? this.narrowing(name, operation)
+            : this.readable(name, operation);
+    }
+    narrowing(name, operation) {
+        const key = `${operation} ${name}`;
+        if (this.narrowed.has(key))
+            return this.narrowed.get(key);
+        this.wanted.set(key, { name, operation });
+        return undefined;
+    }
+}
+/** Plans a query, then again once the `beforeFind` hooks it reached ran. */
+export async function planned(scope, build) {
+    let built = build();
+    while (await scope.ready())
+        built = build();
+    return built;
+}

package/dist/scratch.d.ts

@@ -0,0 +1,14 @@
+import type { Adapter } from './adapter.ts';
+/**
+ * The tables of one test file: until `drop`, each start of the adapter
+ * finds them empty, and no other table is read or written.
+ */
+export type Scratch = {
+    /** Drops them; the adapter's next start is on its own tables again. */
+    readonly drop: () => Promise<void>;
+};
+/** Remembers how `adapter` gives a test file its own tables. */
+export declare function scratchable<T extends Adapter>(adapter: T, scratch: () => Scratch): T;
+/** How `adapter` gives a test file its own tables, if it can. */
+export declare function scratchOf(adapter: Adapter): (() => Scratch) | undefined;
+//# sourceMappingURL=scratch.d.ts.map

package/dist/scratch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch.d.ts","sourceRoot":"","sources":["../src/scratch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAClC,CAAA;AAID,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,CAAC,SAAS,OAAO,EAC5C,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,MAAM,OAAO,GACpB,CAAC,CAGH;AAED,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAEvE"}

package/dist/scratch.js

@@ -0,0 +1,10 @@
+const scratches = new WeakMap();
+/** Remembers how `adapter` gives a test file its own tables. */
+export function scratchable(adapter, scratch) {
+    scratches.set(adapter, scratch);
+    return adapter;
+}
+/** How `adapter` gives a test file its own tables, if it can. */
+export function scratchOf(adapter) {
+    return scratches.get(adapter);
+}

package/dist/serve.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serve.d.ts.map

package/dist/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../src/serve.ts"],"names":[],"mappings":""}

package/dist/serve.js

@@ -0,0 +1,4 @@
+// What `ultimabase dev` runs under `node --watch` (D-105): the application
+// of the config file it is given.
+import { serve } from './cli-main.js';
+process.exitCode = await serve(process.argv[2]);

package/dist/symbols.d.ts

@@ -0,0 +1,10 @@
+export declare const modelFields: unique symbol;
+export declare const fieldType: unique symbol;
+export declare const declaredRecord: unique symbol;
+export declare const pluginTypes: unique symbol;
+export declare const readFilter: unique symbol;
+export declare const typeFields: unique symbol;
+export declare const nullableOf: unique symbol;
+/** Marks a calendar day's options, a string compared in order (D-150). */
+export declare const calendarDay: unique symbol;
+//# sourceMappingURL=symbols.d.ts.map

package/dist/symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../src/symbols.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,CAAC,MAAM,WAAW,EAAE,OAAO,MAAM,CAAA;AAC/C,MAAM,CAAC,OAAO,CAAC,MAAM,SAAS,EAAE,OAAO,MAAM,CAAA;AAC7C,MAAM,CAAC,OAAO,CAAC,MAAM,cAAc,EAAE,OAAO,MAAM,CAAA;AAClD,MAAM,CAAC,OAAO,CAAC,MAAM,WAAW,EAAE,OAAO,MAAM,CAAA;AAC/C,MAAM,CAAC,OAAO,CAAC,MAAM,UAAU,EAAE,OAAO,MAAM,CAAA;AAC9C,MAAM,CAAC,OAAO,CAAC,MAAM,UAAU,EAAE,OAAO,MAAM,CAAA;AAC9C,MAAM,CAAC,OAAO,CAAC,MAAM,UAAU,EAAE,OAAO,MAAM,CAAA;AAC9C,0EAA0E;AAC1E,MAAM,CAAC,OAAO,CAAC,MAAM,WAAW,EAAE,OAAO,MAAM,CAAA"}

package/dist/symbols.js

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

package/dist/transaction.d.ts

@@ -0,0 +1,28 @@
+import type { Adapter, Transaction } from './adapter.ts';
+import type { Running } from './running.ts';
+/** What a query reads and writes through. */
+export type Store = Pick<Transaction, 'find' | 'count' | 'aggregate' | 'write'> & {
+    /**
+     * The write's changes when nothing follows them: alone, they need no
+     * transaction (D-99).
+     */
+    readonly last: Transaction['write'];
+};
+/** A `*Commit` hook, run once the transaction commits (D-15). */
+export type Commit = () => Promise<void>;
+/** A read: in the open transaction, else straight on the adapter. */
+export declare function reading<R>(app: Running, run: (store: Store) => Promise<R>): Promise<R>;
+/** A write: in the open transaction, else in its own (D-36). */
+export declare function writing<R>(app: Running, run: (store: Store, commits: Commit[]) => Promise<R>): Promise<R>;
+/**
+ * Runs `run` in one transaction: if it throws, or if a query in it fails,
+ * every write rolls back and the `*Commit` hooks never run. Inside another
+ * `transaction`, it joins that one (D-36).
+ */
+export declare function transaction<R>(run: () => Promise<R>): Promise<R>;
+/**
+ * Runs an adapter's own statement, `database.sql`, in the running
+ * application's open transaction, else alone (D-137).
+ */
+export declare function joining<R>(adapter: Adapter, run: (tx: Transaction | undefined) => Promise<R>): Promise<R>;
+//# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAKxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAI3C,6CAA6C;AAC7C,MAAM,MAAM,KAAK,GAAG,IAAI,CACvB,WAAW,EACX,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,OAAO,CACxC,GAAG;IACH;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CACnC,CAAA;AAED,iEAAiE;AACjE,MAAM,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;AAyHxC,qEAAqE;AACrE,wBAAsB,OAAO,CAAC,CAAC,EAC9B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,CAAC,CAAC,CAeZ;AAED,gEAAgE;AAChE,wBAAsB,OAAO,CAAC,CAAC,EAC9B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAClD,OAAO,CAAC,CAAC,CAAC,CAMZ;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAQtE;AAED;;;GAGG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAC9B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,CAAC,EAAE,EAAE,WAAW,GAAG,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,GAC9C,OAAO,CAAC,CAAC,CAAC,CAQZ"}

package/dist/transaction.js

@@ -0,0 +1,156 @@
+// Transactions (D-36, D-88): `AsyncLocalStorage` carries the open one, so a
+// hook's queries join it without a `tx` argument.
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+import { RelationViolation } from './adapter.js';
+import { decoded } from './field-codec.js';
+import { recordCount, recordFind } from './recorder.js';
+import { current } from './running.js';
+import { refused } from './write-target.js';
+const opened = new AsyncLocalStorage();
+async function begun(open) {
+    open.tx ??= open.app.adapter.begin();
+    return open.tx;
+}
+/**
+ * The store's rows with their plugin fields decoded (D-122), each read kept
+ * if a recording runs (D-154).
+ */
+function decoding(app, store) {
+    const { models } = app.resolved;
+    return {
+        find: async (read) => {
+            const rows = await store.find(read);
+            recordFind(models, read, rows);
+            return decoded(models, read, rows);
+        },
+        count: async (read) => {
+            recordCount(models, read);
+            return store.count(read);
+        },
+        // It reads no plugin field (D-143).
+        aggregate: async (read) => {
+            recordCount(models, read);
+            return store.aggregate(read);
+        },
+        write: async (write) => decoded(models, write.read, await store.write(write)),
+        last: async (write) => decoded(models, write.read, await store.last(write)),
+    };
+}
+/** Queries in the transaction; `owner`'s last write may run alone. */
+function storeOf(open, owner) {
+    return decoding(open.app, {
+        find: async (read) => (await begun(open)).find(read),
+        count: async (read) => (await begun(open)).count(read),
+        aggregate: async (read) => (await begun(open)).aggregate(read),
+        write: async (write) => (await begun(open)).write(write),
+        last: async (write) => owner && open.tx === undefined
+            ? open.app.adapter.write(write)
+            : (await begun(open)).write(write),
+    });
+}
+/** Runs in the open transaction; a failure rolls all of it back (D-36). */
+async function joined(open, run) {
+    if (open.failure !== undefined) {
+        throw new Error('A query failed in this transaction, which rolls back: no other query runs in it.', { cause: open.failure.error });
+    }
+    try {
+        return await run();
+    }
+    catch (error) {
+        open.failure ??= { error };
+        throw error;
+    }
+}
+async function committed(logger, commits) {
+    for (const commit of commits) {
+        try {
+            await commit();
+        }
+        catch (error) {
+            logger.error({ correlationId: randomUUID(), err: error }, 'A commit hook failed; the write is kept.');
+        }
+    }
+}
+/** A transaction that failed to begin has nothing to roll back. */
+async function rollback(open) {
+    const tx = await open.tx?.catch(() => undefined);
+    await tx?.rollback();
+}
+async function atomic(app, run) {
+    const open = { app, tx: undefined, commits: [], failure: undefined };
+    let result;
+    try {
+        result = await opened.run(open, run, open);
+    }
+    catch (error) {
+        await rollback(open);
+        throw error;
+    }
+    if (open.failure !== undefined) {
+        await rollback(open);
+        throw open.failure.error;
+    }
+    try {
+        await (await open.tx)?.commit();
+    }
+    catch (error) {
+        // A deferred foreign key checks at the commit (D-99).
+        throw error instanceof RelationViolation ? refused(error) : error;
+    }
+    // Outside the transaction: a commit hook's queries open their own.
+    await committed(app.logger, open.commits);
+    return result;
+}
+/** A read: in the open transaction, else straight on the adapter. */
+export async function reading(app, run) {
+    const open = opened.getStore();
+    if (open === undefined) {
+        const { adapter } = app;
+        return run(decoding(app, {
+            find: async (read) => adapter.find(read),
+            count: async (read) => adapter.count(read),
+            aggregate: async (read) => adapter.aggregate(read),
+            write: async (write) => adapter.write(write),
+            last: async (write) => adapter.write(write),
+        }));
+    }
+    return joined(open, async () => run(storeOf(open, false)));
+}
+/** A write: in the open transaction, else in its own (D-36). */
+export async function writing(app, run) {
+    const open = opened.getStore();
+    if (open !== undefined) {
+        return joined(open, async () => run(storeOf(open, false), open.commits));
+    }
+    return atomic(app, async (own) => run(storeOf(own, true), own.commits));
+}
+/**
+ * Runs `run` in one transaction: if it throws, or if a query in it fails,
+ * every write rolls back and the `*Commit` hooks never run. Inside another
+ * `transaction`, it joins that one (D-36).
+ */
+export async function transaction(run) {
+    const open = opened.getStore();
+    if (open !== undefined)
+        return joined(open, run);
+    const app = current();
+    if (app === undefined) {
+        throw new Error('transaction runs on a started application.');
+    }
+    return app.work.run(async () => atomic(app, run));
+}
+/**
+ * Runs an adapter's own statement, `database.sql`, in the running
+ * application's open transaction, else alone (D-137).
+ */
+export async function joining(adapter, run) {
+    const open = opened.getStore();
+    if (open?.app.adapter === adapter) {
+        return joined(open, async () => run(await begun(open)));
+    }
+    const app = current();
+    if (app?.adapter !== adapter)
+        return run(undefined);
+    return app.work.run(async () => run(undefined));
+}

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+import type { ResultOf, RunArgs } from './function.ts';
+import type { Model } from './model.ts';
+import type { AggregateArgs } from './query-aggregate.ts';
+import type { CreateManyAndReturnArgs, CreateManyArgs, UpdateManyAndReturnArgs, UpdateManyArgs } from './query-bulk.ts';
+import type { GroupByArgs } from './query-group.ts';
+import type { CreateArgs, FindFirstArgs, FindManyArgs, FindUniqueArgs, Include, OrderBy, Payload, Select, UpdateArgs, UpsertArgs, Where } from './query.ts';
+import type { CreateData, UpdateData } from './record.ts';
+type Parts<M> = M extends Model<infer N, infer F, infer _P, infer _W, infer X> ? {
+    readonly name: N;
+    readonly fields: F;
+    readonly unique: X;
+} : never;
+type FieldsOf<M> = Parts<M>['fields'];
+type UniqueOf<M> = Parts<M>['unique'];
+type NameOf<M> = Parts<M>['name'];
+type Operations<F, X, N> = {
+    readonly findMany: FindManyArgs<F, X, N>;
+    readonly findFirst: FindFirstArgs<F, X>;
+    readonly findUnique: FindUniqueArgs<F, X>;
+    readonly findFirstOrThrow: FindFirstArgs<F, X>;
+    readonly findUniqueOrThrow: FindUniqueArgs<F, X>;
+    readonly count: {
+        readonly where?: Where<F>;
+    };
+    readonly aggregate: AggregateArgs<F>;
+    readonly groupBy: GroupByArgs<F, N>;
+    readonly create: CreateArgs<F, N>;
+    readonly update: UpdateArgs<F, X, N>;
+    readonly upsert: UpsertArgs<F, X, N>;
+    readonly delete: FindUniqueArgs<F, X>;
+    readonly updateMany: UpdateManyArgs<F>;
+    readonly createMany: CreateManyArgs<F>;
+    readonly updateManyAndReturn: UpdateManyAndReturnArgs<F>;
+    readonly createManyAndReturn: CreateManyAndReturnArgs<F>;
+    readonly deleteMany: {
+        readonly where?: Where<F> | undefined;
+    };
+};
+/** One record, as arguments `A` return it; without them, its scalars. */
+export type RecordOf<M, A = {}> = Payload<FieldsOf<M>, A>;
+export type WhereOf<M> = Where<FieldsOf<M>>;
+export type IncludeOf<M> = Include<FieldsOf<M>>;
+export type SelectOf<M> = Select<FieldsOf<M>>;
+export type OrderByOf<M> = OrderBy<FieldsOf<M>>;
+export type CreateDataOf<M> = CreateData<FieldsOf<M>, NameOf<M>>;
+export type UpdateDataOf<M> = UpdateData<FieldsOf<M>, NameOf<M>>;
+/** The arguments of one operation of the model. */
+export type ArgsOf<M, O extends keyof Operations<FieldsOf<M>, UniqueOf<M>, NameOf<M>>> = Operations<FieldsOf<M>, UniqueOf<M>, NameOf<M>>[O];
+/** What a caller sends to a function, before validation. */
+export type InputOf<Fn> = Fn extends {
+    readonly input: infer I;
+} ? RunArgs<I> extends readonly [input: infer V, options?: unknown] ? V : undefined : never;
+/** What a function returns. */
+export type OutputOf<Fn> = Fn extends {
+    readonly output: infer O;
+} ? ResultOf<O> : never;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

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

package/dist/update-many.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from './query-context.ts';
+import type { Commit, Store } from './transaction.ts';
+export declare function updateMany(context: Context, store: Store, commits: Commit[], args: unknown): Promise<{
+    readonly count: number;
+}>;
+export declare function updateManyAndReturn(context: Context, store: Store, commits: Commit[], args: unknown): Promise<readonly unknown[]>;
+//# sourceMappingURL=update-many.d.ts.map

package/dist/update-many.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-many.d.ts","sourceRoot":"","sources":["../src/update-many.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAKjD,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAoOrD,wBAAsB,UAAU,CAC/B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,OAAO,GACX,OAAO,CAAC;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAIrC;AAED,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,SAAS,OAAO,EAAE,CAAC,CAK7B"}

package/dist/update-many.js

@@ -0,0 +1,182 @@
+// `updateMany` (D-133): what an `update` runs, on each row its `where`
+// selects, all or nothing; one write when nothing needs the rows (D-99).
+// `updateManyAndReturn` returns them in `id` order, each as `update` does
+// (D-149).
+import { recordOf } from './access.js';
+import { InvalidQuery } from './errors.js';
+import { rereads, runHook, settle } from './hooks.js';
+import { computeOn, operationsOf, inRange, validates } from './number-update.js';
+import { oneKeys } from './query-args.js';
+import { filtered, given, shapedRows } from './query-context.js';
+import { byIds, entries } from './query-where.js';
+import { updatePlan } from './query-write.js';
+import { prepared, readData } from './write-data.js';
+import { updated } from './write-plan.js';
+import { checkedWrite, guarded } from './write-target.js';
+import { writingOf } from './writing.js';
+import { returned } from './writes.js';
+// In id order, so two calls on the same rows wait instead of deadlocking.
+const orderBy = [{ field: 'id', direction: 'asc' }];
+/** The scalar data of the rows, as `update` reads it (D-133 point 2). */
+function scalarData(context, data) {
+    const { models, model } = context;
+    for (const [name] of entries(data, 'data')) {
+        if (model.fields.get(name)?.kind === 'scalar')
+            continue;
+        if (!model.fields.has(name))
+            continue;
+        const path = `data.${name}`;
+        throw new InvalidQuery(path, `${path} is a relation, which updateMany does not write.`);
+    }
+    return readData(models, model, data, false);
+}
+/** The plan's update, spread to every row `where` selects. */
+function spread(plan, where) {
+    return plan.steps.flatMap((step) => step.kind === 'update' ? [{ ...step, where }] : []);
+}
+const same = (a, b) => {
+    const keys = Object.keys(a.draft);
+    return (keys.length === Object.keys(b.draft).length &&
+        keys.every((key) => Object.hasOwn(b.draft, key) && Object.is(a.draft[key], b.draft[key])) &&
+        [...a.operations.keys()].join() === [...b.operations.keys()].join());
+};
+/**
+ * A row's data after its hooks: a number or list they left as computed is
+ * computed by the write again, the row being locked, so rows share one
+ * statement.
+ */
+function settled(item, operations) {
+    const left = new Map(operations);
+    const draft = { ...item.draft };
+    for (const name of operations.keys()) {
+        if (Object.is(item.draft[name], item.sent[name]))
+            delete draft[name];
+        else
+            left.delete(name);
+    }
+    return { draft, operations: left };
+}
+/** The rows by data; one a hook gave a relation write is planned alone. */
+function grouped(model, items, operations) {
+    const groups = [];
+    for (const item of items) {
+        const each = settled(item, operations);
+        const scalars = Object.keys(each.draft).every((name) => model.fields.get(name)?.kind === 'scalar');
+        const found = scalars
+            ? groups.find((group) => same(group, each))
+            : undefined;
+        if (found === undefined)
+            groups.push({ ...each, items: [item] });
+        else
+            found.items.push(item);
+    }
+    return groups;
+}
+/**
+ * Each row through the update rule and hooks, then their writes (D-133):
+ * the rows changed, or with `at` as it shapes them.
+ */
+async function lockedRows(context, store, commits, data, where, at) {
+    const { model, caller, scope } = context;
+    const { operations } = data;
+    const rows = await store.find({
+        model: model.name,
+        where,
+        orderBy,
+        lock: true,
+    });
+    const items = rows.map((row) => {
+        const draft = { ...data.draft };
+        computeOn(model, row, draft, operations);
+        return { row, draft, sent: { ...draft } };
+    });
+    // One row refused, none written (D-111).
+    for (const { row, sent } of items) {
+        scope.access?.allow(model, 'update', { record: row, data: sent });
+    }
+    if (items.length === 0)
+        return [];
+    for (const { row, draft } of items) {
+        await prepared(model, draft, caller, false);
+        const record = recordOf(model, row);
+        await runHook(model, 'beforeUpdate', { caller, record, data: draft });
+    }
+    const events = items.map(({ row }) => ({
+        model,
+        operation: 'update',
+        id: row.id,
+        before: row,
+    }));
+    const writing = writingOf(scope, store, events);
+    const changes = [];
+    for (const group of grouped(model, items, operations)) {
+        const [{ row, sent }] = group.items;
+        const plan = await updatePlan(scope, model, row.id, group.draft, sent, store, group.operations);
+        events.push(...plan.events);
+        await plan.check(writing);
+        const ids = group.items.map((item) => item.row.id);
+        const one = ids.length === 1;
+        changes.push(...(one
+            ? await plan.changes(writing)
+            : spread(plan, { id: { in: ids } })));
+    }
+    const ids = items.map((item) => item.row.id);
+    const read = at && {
+        model: model.name,
+        ...at.read,
+        where: byIds(ids),
+        orderBy,
+    };
+    // An `after*` hook may change the rows: they are read once it ran (D-88).
+    const again = rereads(events);
+    const written = await inRange(model, checkedWrite(store, writing.checks, changes, again ? undefined : read));
+    await settle(store, caller, events, commits);
+    if (at === undefined || read === undefined)
+        return ids;
+    const result = again ? await store.find(read) : written;
+    return shapedRows(context, store, result, at.shape, scope.access);
+}
+/**
+ * Updates the rows `where` selects: their ids, or with `at` the rows as it
+ * shapes them, in `id` order. The rows come back even when a read rule
+ * would hide them, as `update`'s does (D-86).
+ */
+async function updating(context, store, commits, found, at) {
+    const { model, caller, scope } = context;
+    const draft = scalarData(context, found.get('data'));
+    const operations = operationsOf(model, draft);
+    const where = (await filtered(context, found, 'update')) ?? {};
+    // A relation read beside the UPDATE would see its rows as they were.
+    const nests = at?.read.include !== undefined || at?.read.count !== undefined;
+    if (scope.access !== undefined ||
+        updated(model) ||
+        validates(model, operations) ||
+        nests) {
+        const data = { draft, operations };
+        return lockedRows(context, store, commits, data, where, at);
+    }
+    // Nothing needs the stored rows: one UPDATE, which computes the numbers
+    // and lists and returns the rows it changed (D-104).
+    await prepared(model, draft, caller, false);
+    const plan = await updatePlan(scope, model, '', draft, draft, store, operations);
+    const write = {
+        changes: spread(plan, where),
+        read: { model: model.name, ...at?.read, orderBy },
+        before: true,
+    };
+    const rows = await inRange(model, guarded(store.last(write), []));
+    if (at === undefined)
+        return rows.map((row) => row.id);
+    return shapedRows(context, store, rows, at.shape, scope.access);
+}
+export async function updateMany(context, store, commits, args) {
+    const found = given(args, context.model.name, ['where', 'data'], ['data']);
+    const ids = await updating(context, store, commits, found);
+    return { count: ids.length };
+}
+export async function updateManyAndReturn(context, store, commits, args) {
+    const keys = ['where', 'data', ...oneKeys];
+    const found = given(args, context.model.name, keys, ['data']);
+    const at = await returned(context, found);
+    return updating(context, store, commits, found, at);
+}

package/dist/uuid.d.ts

@@ -0,0 +1,7 @@
+export declare function uuidv7(): string;
+/**
+ * The id of the row a nested `create` makes from `data`: made once, so its
+ * relation's field rule sees it before the row is planned (D-128).
+ */
+export declare function madeId(data: object): string;
+//# sourceMappingURL=uuid.d.ts.map

package/dist/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":"AAMA,wBAAgB,MAAM,IAAI,MAAM,CAgC/B;AAID;;;GAGG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI3C"}

package/dist/uuid.js

@@ -0,0 +1,48 @@
+// UUIDv7 ids (D-22, RFC 9562): a millisecond timestamp, then a 12-bit counter
+// in `rand_a` so that ids made in the same millisecond still sort in order.
+let lastTime = 0;
+let counter = 0;
+export function uuidv7() {
+    let time = Date.now();
+    if (time > lastTime) {
+        lastTime = time;
+        counter = 0;
+    }
+    else {
+        counter += 1;
+        if (counter > 0xfff) {
+            lastTime += 1;
+            counter = 0;
+        }
+        time = lastTime;
+    }
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    for (let index = 5; index >= 0; index -= 1) {
+        bytes[index] = time % 256;
+        time = Math.floor(time / 256);
+    }
+    bytes[6] = 0x70 | (counter >> 8);
+    bytes[7] = counter & 0xff;
+    bytes[8] = 0x80 | ((bytes[8] ?? 0) & 0x3f);
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0'));
+    return [
+        hex.slice(0, 4),
+        hex.slice(4, 6),
+        hex.slice(6, 8),
+        hex.slice(8, 10),
+        hex.slice(10, 16),
+    ]
+        .map((part) => part.join(''))
+        .join('-');
+}
+const made = new WeakMap();
+/**
+ * The id of the row a nested `create` makes from `data`: made once, so its
+ * relation's field rule sees it before the row is planned (D-128).
+ */
+export function madeId(data) {
+    const id = made.get(data) ?? uuidv7();
+    made.set(data, id);
+    return id;
+}