ultimabase 0.0.0-stage → 0.1.0

package/dist/write-data.js

@@ -0,0 +1,144 @@
+import { InvalidQuery, PublicError } from './errors.js';
+import { entries, integerRange, isObject, misfit, unknownKey, } from './query-where.js';
+import { checked, validated } from './validation.js';
+import { manyWrite, oneWrite } from './relation-write.js';
+import { refuseSet } from './relations.js';
+/** A value's issue; each element of a list fits its type (D-127). */
+export function issueOf(value, field) {
+    if (!field.list)
+        return misfit(value, field);
+    const fit = (item) => item !== '' && misfit(item, field) === undefined;
+    if (Array.isArray(value) && value.every(fit))
+        return undefined;
+    const of = field.type === 'enum'
+        ? `values among ${(field.values ?? []).join(', ')}`
+        : field.integer === true
+            ? `whole numbers ${integerRange}`
+            : field.type === 'number'
+                ? 'finite numbers'
+                : 'non-empty strings without a NUL or a lone surrogate';
+    return `Expected a list of ${of}.`;
+}
+/**
+ * The caller's data, its shape checked, as a draft the hooks may change: a
+ * copy, down to the rows it creates and updates, which never write the
+ * relation they are written through (D-128, D-138).
+ */
+export function readData(models, model, data, creating, at = 'data', inverse) {
+    const draft = {};
+    for (const [name, value] of entries(data, at)) {
+        const field = model.fields.get(name);
+        const path = `${at}.${name}`;
+        // A view is read-only (D-151).
+        if (field === undefined ||
+            (field.kind === 'many' && field.from !== undefined)) {
+            throw unknownKey(path, model.name);
+        }
+        if (name === inverse) {
+            throw new InvalidQuery(path, `${path} cannot be written: it links to the row being written.`);
+        }
+        draft[name] = value;
+        if (field.kind === 'scalar')
+            continue;
+        const target = models.get(field.target);
+        const nested = (item, where, creates = true) => target === undefined
+            ? item
+            : readData(models, target, item, creates, where, field.inverse);
+        const orCreated = (item, where) => ({
+            where: item.where,
+            create: nested(item.create, `${where}.create`),
+        });
+        if (field.kind === 'one') {
+            const write = oneWrite(value, path, model.name, creating);
+            const to = `${path}.${write.kind}`;
+            if (write.kind === 'create' || write.kind === 'update') {
+                const copy = nested(write.data, to, write.kind === 'create');
+                draft[name] = { [write.kind]: copy };
+            }
+            else if (write.kind === 'connectOrCreate') {
+                draft[name] = { connectOrCreate: orCreated(write, to) };
+            }
+            continue;
+        }
+        const write = manyWrite(value, path, model.name, creating);
+        if (write.set !== undefined)
+            refuseSet(model, name, `${path}.set`);
+        const copy = { ...(isObject(value) ? value : {}) };
+        const to = (key, index) => `${path}.${key}.${index}`;
+        if (Object.hasOwn(copy, 'create')) {
+            copy['create'] = write.create.map((item, index) => nested(item, to('create', index)));
+        }
+        if (Object.hasOwn(copy, 'connectOrCreate')) {
+            copy['connectOrCreate'] = write.connectOrCreate.map((item, index) => orCreated(item, to('connectOrCreate', index)));
+        }
+        if (Object.hasOwn(copy, 'update')) {
+            copy['update'] = write.update.map((item, index) => ({
+                where: item.where,
+                data: nested(item.data, `${to('update', index)}.data`, false),
+            }));
+        }
+        draft[name] = copy;
+    }
+    return draft;
+}
+/** A relation default's id: the target's `{ id }` or a record of it (D-53). */
+function idOf(model, field, value) {
+    const id = isObject(value) ? value['id'] : undefined;
+    if (typeof id !== 'string') {
+        throw new TypeError(`${model.name}.${field.name}: a relation's default is the target's { id } or a record of it.`);
+    }
+    return id;
+}
+function defaults(model, draft, caller) {
+    for (const field of model.fields.values()) {
+        if (Object.hasOwn(draft, field.name) || field.kind === 'many')
+            continue;
+        const fallback = field.options['default'];
+        const value = typeof fallback === 'function'
+            ? Reflect.apply(fallback, undefined, [{ caller }])
+            : fallback;
+        if (value === undefined)
+            continue;
+        draft[field.name] =
+            field.kind === 'one'
+                ? { connect: { id: idOf(model, field, value) } }
+                : value;
+    }
+}
+/**
+ * Gives a create its defaults, then checks each value's type and runs its
+ * `validate`, whose output replaces it: defaults are validated, hook values
+ * are not (D-67).
+ */
+export async function prepared(model, draft, caller, creating, at = []) {
+    if (creating)
+        defaults(model, draft, caller);
+    const issues = [];
+    for (const [name, value] of Object.entries(draft)) {
+        const field = model.fields.get(name);
+        if (field?.kind !== 'scalar' || value === null)
+            continue;
+        const { codec } = field;
+        // A plugin field's schema takes the value or its JSON (D-122).
+        const issue = codec === undefined ? issueOf(value, field) : undefined;
+        if (issue !== undefined) {
+            issues.push({ path: [name], message: issue });
+            continue;
+        }
+        const result = codec === undefined
+            ? await validated(model, field, value)
+            : await checked(codec.schema, value, [name], `${model.name}.${name}`);
+        if ('issues' in result)
+            issues.push(...result.issues);
+        else
+            draft[name] = result.value;
+    }
+    if (issues.length > 0) {
+        throw invalid(issues.map((one) => ({ ...one, path: [...at, ...one.path] })));
+    }
+}
+export function invalid(issues) {
+    return new PublicError('VALIDATION_FAILED', 'Invalid data.', {
+        details: { issues },
+    });
+}

package/dist/write-plan.d.ts

@@ -0,0 +1,107 @@
+import type { Change, Check, Filter, Row } from './adapter.ts';
+import type { Except } from './cascade.ts';
+import type { Issue } from './errors.ts';
+import type { Event } from './hooks.ts';
+import type { ModelInfo } from './schema.ts';
+import type { QueryScope } from './scope.ts';
+import type { Store } from './transaction.ts';
+import type { Draft } from './write-data.ts';
+/** The reads a write needs before it runs. */
+export type Reads = Pick<Store, 'find' | 'count'>;
+/**
+ * A relation write from the other side: the target rows `where` selects
+ * take `to` as their key `field`, under the target's rules (D-78).
+ */
+export type Move = {
+    readonly kind: 'move';
+    readonly model: string;
+    readonly field: string;
+    /** The relation written, as `Post.comments` (D-82). */
+    readonly via: string;
+    readonly where: Filter;
+    readonly to: string | null;
+    /** A default's or a hook's value, which skips access rules (D-67). */
+    readonly trusted: boolean;
+};
+type Link = Extract<Change, {
+    readonly kind: 'link' | 'unlink';
+}>;
+/** A join's `unlink`, kept to the `target` rows the caller reads (D-86). */
+export type Detach = Omit<Link, 'kind'> & {
+    readonly kind: 'detach';
+    readonly target: string;
+    readonly trusted: boolean;
+};
+/** A nested delete (D-138): its rows and their cascade, as `Target.delete`. */
+export type Drop = {
+    readonly kind: 'drop';
+    readonly model: string;
+    readonly rows: readonly Row[];
+    /** Where it sits in the write's data. */
+    readonly path: string;
+    /** The key the parent empties itself, which the cascade leaves. */
+    readonly except?: Except;
+    /** The rows the write updates, as `Model:id`: none may be deleted. */
+    readonly written: ReadonlySet<string>;
+};
+export type Step = Change | Move | Detach | Drop;
+/**
+ * A check of the write, and what `NOT_FOUND` says when it fails (D-99), or
+ * the relation a failed `RELATION_RESTRICTED` names (D-102).
+ */
+export type Checked = {
+    readonly check: Check;
+    readonly message: string;
+    readonly restricted?: {
+        readonly model: string;
+        readonly field: string;
+    };
+};
+/**
+ * What one write runs in: its store, its scope, the rows it changes and the
+ * checks its changes need.
+ */
+export type Writing = {
+    readonly store: Store;
+    readonly scope: QueryScope;
+    readonly events: Event[];
+    readonly checks: Checked[];
+    /** The changes a moved row's `beforeUpdate` added to its data. */
+    readonly replan: (model: ModelInfo, id: string, draft: Draft) => Promise<Plan>;
+    /** A nested delete's changes, its cascade and hooks run (D-138). */
+    readonly drop: (step: Drop) => Promise<Change[]>;
+};
+/** Whether a model has update hooks, which need each row it updates. */
+export declare function updated(model: ModelInfo): boolean;
+/**
+ * The changes giving `rows` of `target` the key `to`, through the target's
+ * update hooks when it has some (D-88, D-90).
+ */
+export declare function moved(step: Pick<Move, 'model' | 'field' | 'to'>, target: ModelInfo, rows: readonly Row[], writing: Writing): Promise<Change[]>;
+/** The steps of one write, and the ids its `connect`s need to exist. */
+export declare class Plan {
+    readonly steps: Step[];
+    readonly issues: Issue[];
+    /** The rows its nested `create`s make, their hooks run (D-128). */
+    readonly events: Event[];
+    /** The ids of the rows it creates, which a `connect` needs not find. */
+    readonly made: Set<string>;
+    /** The rows it updates, as `Model:id` (D-138). */
+    readonly written: Set<string>;
+    private readonly connected;
+    /** Connected ids, which a move updates and any other connect reads (D-124). */
+    connect(model: string, ids: readonly string[], trusted: boolean, operation: 'read' | 'update'): void;
+    /**
+     * Fails with the issues, then adds the write's checks: a target that is
+     * missing or that the write cannot reach is `NOT_FOUND` (D-86, D-99).
+     */
+    check(writing: Writing): Promise<void>;
+    /**
+     * The adapter's changes. A relation written from the other side runs the
+     * target's rules and update hooks on each row it changes, and leaves the
+     * rows the write cannot reach (D-78, D-86, D-88).
+     */
+    changes(writing: Writing): Promise<Change[]>;
+}
+export {};
+//# sourceMappingURL=write-plan.d.ts.map

package/dist/write-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-plan.d.ts","sourceRoot":"","sources":["../src/write-plan.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAI5C,8CAA8C;AAC9C,MAAM,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAA;AAEjD;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,uDAAuD;IACvD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAC,CAAA;AAEjE,4EAA4E;AAC5E,MAAM,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG;IACzC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,+EAA+E;AAC/E,MAAM,MAAM,IAAI,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAA;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAAA;AAEhD;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CACxE,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,CAAA;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9E,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CAChD,CAAA;AAKD,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAMjD;AAiED;;;GAGG;AACH,wBAAsB,KAAK,CAC1B,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC,EAC1C,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,GAAG,EAAE,EACpB,OAAO,EAAE,OAAO,GACd,OAAO,CAAC,MAAM,EAAE,CAAC,CAQnB;AAoBD,wEAAwE;AACxE,qBAAa,IAAI;IAChB,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,CAAK;IAC3B,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAK;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAK;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IACtC,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAQvB;IAEH,+EAA+E;IAC/E,OAAO,CACN,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAAG,QAAQ,GAC1B,IAAI,CAUN;IAED;;;OAGG;IACG,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAe3C;IAED;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWjD;CACD"}

package/dist/write-plan.js

@@ -0,0 +1,170 @@
+// The steps of one write, before access rules and `beforeFind` turn them
+// into the adapter's changes (D-71, D-78, D-86).
+import { and, recordOf } from './access.js';
+import { PublicError } from './errors.js';
+import { hasHook, runHook } from './hooks.js';
+import { invalid } from './write-data.js';
+import { byId, byIds, modelOf } from './query-where.js';
+/** The shape of every id the kernel makes (D-22). */
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** Whether a model has update hooks, which need each row it updates. */
+export function updated(model) {
+    return (hasHook(model, 'beforeUpdate') ||
+        hasHook(model, 'afterUpdate') ||
+        hasHook(model, 'afterUpdateCommit'));
+}
+/** Each moved row's update hooks (D-88): the relation stays as asked. */
+async function hooked(step, target, rows, writing) {
+    const { model, field, to } = step;
+    const changes = [];
+    for (const row of rows) {
+        const data = {
+            [field]: to === null ? { disconnect: true } : { connect: { id: to } },
+        };
+        await runHook(target, 'beforeUpdate', {
+            caller: writing.scope.caller,
+            record: recordOf(target, row),
+            data,
+        });
+        Reflect.deleteProperty(data, field);
+        const set = { [field]: to, updatedAt: new Date(Date.now()) };
+        changes.push({ kind: 'update', model, where: byId(row.id), set });
+        writing.events.push({
+            model: target,
+            operation: 'update',
+            id: row.id,
+            before: row,
+        });
+        if (Object.keys(data).length === 0)
+            continue;
+        const plan = await writing.replan(target, row.id, data);
+        writing.events.push(...plan.events);
+        await plan.check(writing);
+        changes.push(...(await plan.changes(writing)));
+    }
+    return changes;
+}
+/**
+ * The target rows a move changes, each allowed by the target's rules: it
+ * updates them (D-124).
+ */
+async function move(step, writing) {
+    const { model, field, via, where, to, trusted } = step;
+    const { scope, store } = writing;
+    const target = modelOf(scope.models, model);
+    const filter = await scope.filter(model, trusted, 'update');
+    const access = trusted ? undefined : scope.access;
+    const set = { [field]: to, updatedAt: new Date(Date.now()) };
+    if (access === undefined && !updated(target)) {
+        return [{ kind: 'update', model, where: and(where, filter), set }];
+    }
+    const rows = await store.find({
+        model,
+        where: and(where, filter),
+        lock: true,
+    });
+    const data = {
+        [field]: to === null ? { disconnect: true } : { connect: { id: to } },
+    };
+    for (const record of rows)
+        access?.allow(target, 'update', { record, data, via });
+    return moved(step, target, rows, writing);
+}
+/**
+ * The changes giving `rows` of `target` the key `to`, through the target's
+ * update hooks when it has some (D-88, D-90).
+ */
+export async function moved(step, target, rows, writing) {
+    if (updated(target))
+        return hooked(step, target, rows, writing);
+    if (rows.length === 0)
+        return [];
+    const { model, field, to } = step;
+    const set = { [field]: to, updatedAt: new Date(Date.now()) };
+    return [
+        { kind: 'update', model, where: byIds(rows.map((row) => row.id)), set },
+    ];
+}
+/** A join's `unlink`, kept to the targets the write reaches. */
+async function detach(step, writing) {
+    const { target, targets, trusted, ...link } = step;
+    const filter = await writing.scope.filter(target, trusted);
+    const kept = filter === undefined
+        ? targets
+        : (await writing.store.find({
+            model: target,
+            where: and(byIds(targets), filter),
+            lock: true,
+        })).map((row) => row.id);
+    if (kept.length === 0)
+        return [];
+    return [{ ...link, kind: 'unlink', targets: kept }];
+}
+/** The steps of one write, and the ids its `connect`s need to exist. */
+export class Plan {
+    steps = [];
+    issues = [];
+    /** The rows its nested `create`s make, their hooks run (D-128). */
+    events = [];
+    /** The ids of the rows it creates, which a `connect` needs not find. */
+    made = new Set();
+    /** The rows it updates, as `Model:id` (D-138). */
+    written = new Set();
+    connected = new Map();
+    /** Connected ids, which a move updates and any other connect reads (D-124). */
+    connect(model, ids, trusted, operation) {
+        const key = `${model}:${String(trusted)}:${operation}`;
+        const group = this.connected.get(key) ?? {
+            model,
+            trusted,
+            operation,
+            ids: new Set(),
+        };
+        for (const id of ids)
+            group.ids.add(id);
+        this.connected.set(key, group);
+    }
+    /**
+     * Fails with the issues, then adds the write's checks: a target that is
+     * missing or that the write cannot reach is `NOT_FOUND` (D-86, D-99).
+     */
+    async check(writing) {
+        if (this.issues.length > 0)
+            throw invalid(this.issues);
+        for (const group of this.connected.values()) {
+            const { model, trusted, operation } = group;
+            const ids = new Set([...group.ids].filter((id) => !this.made.has(id)));
+            if (ids.size === 0)
+                continue;
+            const message = `A connected ${model} does not exist.`;
+            // No row has an id the kernel cannot have made.
+            if (![...ids].every((id) => uuid.test(id))) {
+                throw new PublicError('NOT_FOUND', message);
+            }
+            const filter = await writing.scope.filter(model, trusted, operation);
+            const where = and(byIds([...ids]), filter);
+            writing.checks.push({ check: { model, where, count: ids.size }, message });
+        }
+    }
+    /**
+     * The adapter's changes. A relation written from the other side runs the
+     * target's rules and update hooks on each row it changes, and leaves the
+     * rows the write cannot reach (D-78, D-86, D-88).
+     */
+    async changes(writing) {
+        const changes = [];
+        for (const step of this.steps) {
+            if (step.kind === 'move')
+                changes.push(...(await move(step, writing)));
+            else if (step.kind === 'detach') {
+                changes.push(...(await detach(step, writing)));
+            }
+            else if (step.kind === 'drop') {
+                changes.push(...(await writing.drop(step)));
+            }
+            else
+                changes.push(step);
+        }
+        return changes;
+    }
+}

package/dist/write-target.d.ts

@@ -0,0 +1,17 @@
+import type { Change, Filter, Read, Row } from './adapter.ts';
+import { RelationViolation } from './adapter.ts';
+import { PublicError } from './errors.ts';
+import type { Context } from './query-context.ts';
+import type { Store } from './transaction.ts';
+import type { Checked } from './write-plan.ts';
+/** A relation the database refused, as the kernel's own checks word it. */
+export declare function refused(error: RelationViolation): PublicError;
+/**
+ * Writes `changes` after `checks`, each failed check its own error, then
+ * reads `read`.
+ */
+export declare const checkedWrite: (store: Store, checks: readonly Checked[], changes: readonly Change[], read?: Read) => Promise<Row[]>;
+export declare function guarded(run: Promise<Row[]>, checks: readonly Checked[]): Promise<Row[]>;
+/** The stored row a single-row write targets, locked (D-99, D-104). */
+export declare function target(context: Context, store: Store, where: Filter): Promise<Row>;
+//# sourceMappingURL=write-target.d.ts.map

package/dist/write-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-target.d.ts","sourceRoot":"","sources":["../src/write-target.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAe,iBAAiB,EAAmB,MAAM,cAAc,CAAA;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAE9C,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,KAAK,EAAE,iBAAiB,GAAG,WAAW,CAa7D;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,UACjB,KAAK,UACJ,SAAS,OAAO,EAAE,WACjB,SAAS,MAAM,EAAE,SACnB,IAAI,KACT,OAAO,CAAC,GAAG,EAAE,CAQd,CAAA;AAEF,wBAAsB,OAAO,CAC5B,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,EACnB,MAAM,EAAE,SAAS,OAAO,EAAE,GACxB,OAAO,CAAC,GAAG,EAAE,CAAC,CAwBhB;AAED,uEAAuE;AACvE,wBAAsB,MAAM,CAC3B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,GAAG,CAAC,CAad"}

package/dist/write-target.js

@@ -0,0 +1,59 @@
+import { CheckFailed, RelationViolation, UniqueViolation } from './adapter.js';
+import { PublicError } from './errors.js';
+/** A relation the database refused, as the kernel's own checks word it. */
+export function refused(error) {
+    const { model, field } = error;
+    return error.restricted
+        ? new PublicError('RELATION_RESTRICTED', `${model}.${field} references a ${error.target} the delete removes.`, { details: { model, field }, cause: error })
+        : new PublicError('NOT_FOUND', `A connected ${error.target} does not exist.`, { cause: error });
+}
+/**
+ * Writes `changes` after `checks`, each failed check its own error, then
+ * reads `read`.
+ */
+export const checkedWrite = async (store, checks, changes, read) => guarded(store.write({
+    checks: checks.map(({ check }) => check),
+    changes,
+    ...(read && { read }),
+}), checks);
+export async function guarded(run, checks) {
+    try {
+        return await run;
+    }
+    catch (error) {
+        const failed = error instanceof CheckFailed ? checks[error.index] : undefined;
+        if (failed?.restricted !== undefined) {
+            throw new PublicError('RELATION_RESTRICTED', failed.message, {
+                details: { ...failed.restricted },
+                cause: error,
+            });
+        }
+        if (failed !== undefined) {
+            throw new PublicError('NOT_FOUND', failed.message, { cause: error });
+        }
+        if (error instanceof RelationViolation)
+            throw refused(error);
+        if (error instanceof UniqueViolation) {
+            throw new PublicError('UNIQUE_VIOLATION', error.message, {
+                details: { model: error.model, fields: [...error.fields] },
+                cause: error,
+            });
+        }
+        throw error;
+    }
+}
+/** The stored row a single-row write targets, locked (D-99, D-104). */
+export async function target(context, store, where) {
+    const { model } = context;
+    const [row] = await store.find({
+        model: model.name,
+        where,
+        take: 1,
+        lock: true,
+    });
+    // A row the caller cannot read is not found (D-72).
+    if (row === undefined) {
+        throw new PublicError('NOT_FOUND', `No ${model.name} matches.`);
+    }
+    return row;
+}

package/dist/writes.d.ts

@@ -0,0 +1,23 @@
+import type { Nested } from './adapter.ts';
+import type { Context } from './query-context.ts';
+import type { Shape } from './query-args.ts';
+import type { Commit, Store } from './transaction.ts';
+/** The shape a single-row write returns, and each row of a bulk one's (D-149). */
+export declare function returned(context: Context, found: ReadonlyMap<string, unknown>): Promise<{
+    readonly read: Nested;
+    readonly shape: Shape;
+}>;
+export declare function create(context: Context, store: Store, commits: Commit[], args: unknown): Promise<unknown>;
+export declare function update(context: Context, store: Store, commits: Commit[], args: unknown): Promise<unknown>;
+export declare function remove(context: Context, store: Store, commits: Commit[], args: unknown): Promise<unknown>;
+/** The row an upsert returns, and whether it created it (D-142). */
+export type Upserted = {
+    readonly row: unknown;
+    readonly created: boolean;
+};
+/**
+ * Updates the row `where` targets, or creates it when the caller finds
+ * none: the branch that runs is a plain update or create (D-142).
+ */
+export declare function upsert(context: Context, store: Store, commits: Commit[], args: unknown): Promise<Upserted>;
+//# sourceMappingURL=writes.d.ts.map

package/dist/writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.d.ts","sourceRoot":"","sources":["../src/writes.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAU,MAAM,EAAO,MAAM,cAAc,CAAA;AAMvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAIjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAO5C,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAUrD,kFAAkF;AAClF,wBAAsB,QAAQ,CAC7B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,CAK3D;AAkED,wBAAsB,MAAM,CAC3B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,OAAO,CAAC,CAMlB;AA6DD,wBAAsB,MAAM,CAC3B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,OAAO,CAAC,CAiDlB;AAED,wBAAsB,MAAM,CAC3B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,OAAO,CAAC,CA0ElB;AAED,oEAAoE;AACpE,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAA;AAE3E;;;GAGG;AACH,wBAAsB,MAAM,CAC3B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,QAAQ,CAAC,CA8BnB"}