@kanf/wema-kake 0.1.1 → 0.1.3

package/dist/lib/worker/page-do.js

@@ -4,7 +4,7 @@ import { invertDeltas, } from '../shared/delta';
 import { systemSummary } from '../shared/op-summary';
 import { CLOSE_AUTH_EXPIRED, CLOSE_PAGE_DELETED, PING, PONG, } from '../shared/protocol';
 import { childPageOf, childRejection, MAX_DEPTH, placedPages, touchesChildren, } from '../shared/hierarchy';
-import { applyDeltas, childNoteColors, childPages, readBoard, readBoardWithAuthors, readBoardWithInfos, readNotes, sanitizeDeltas, UNSET_FLAGS, } from './apply-ops';
+import { applyDeltas, childNoteColors, childPages, readBoard, readBoardWithAuthors, readBoardWithInfos, readNotes, readNotesAmong, sanitizeDeltas, UNSET_FLAGS, } from './apply-ops';
 import { buildLayout, buildPageContent, contentHash, indexedChildren, removePage, touchPage, writePage, } from './indexer';
 import { applyRevert } from './revert';
 import { SanitizeError } from './sanitize';
@@ -30,6 +30,9 @@ function isExpired(attachment) {
 }
 /** ページがないときの `reason`。Worker は、これを 404 にする */
 export const REASON_PAGE_NOT_FOUND = 'page not found';
+/** 作成のデルタで作る付箋（デルタの順） */
+const createdNotes = (deltas) => deltas.flatMap((d) => (d.type === 'note:create' ? [d.note] : []));
+const createdNoteIds = (deltas) => createdNotes(deltas).map((note) => note.id);
 /** 受け取った付箋と、今ある付箋の間に空ける幅 */
 const RECEIVE_GAP = 40;
 /**
@@ -519,7 +522,7 @@ export class PageDO extends DurableObject {
             opId: crypto.randomUUID(),
             deltas: notes.map((note) => ({ type: 'note:update', noteId: note.id, before: { color: note.color }, after: { color } })),
             summary: systemSummary.childRecolored(page),
-        }, undefined, false);
+        }, { matchColors: false });
     }
     /**
      * ページを削除する前に、階層から外す。親ページにある自分の付箋を消し、子ページはルートへ戻す
@@ -740,6 +743,9 @@ export class PageDO extends DurableObject {
      * 他のページから移す（写す）付箋と、その間の接続線を受け取って置く。互いの位置関係は保ち、
      * 今ある付箋の下に置く（送る側は、このページの付箋の位置を知らない）。
      * ページがまだ作られていなければ、作らずに断る。
+     *
+     * 付箋の中身を送る側が渡す形なので、作成者は送った人になる。画面は takeNotes（Worker の
+     * transferNotes）を使う。これは、更新の前に開いた画面のタブが使う
      */
     receiveNotes(input) {
         return this.write(async () => {
@@ -755,13 +761,127 @@ export class PageDO extends DurableObject {
                 ],
                 summary: systemSummary.notesReceived(from),
                 mustExist: true,
-            }, (deltas) => placeBelow(deltas.flatMap((d) => (d.type === 'note:create' ? [d.note] : [])), this.sql
-                .exec(`SELECT min(x) AS left, max(y + height) AS bottom FROM notes`)
-                .one()));
+            }, { prepare: (deltas) => this.placeBelowNotes(deltas) });
         }, 
         // 呼び出し側（Worker）は、ページがないときと同じに扱う
         { ok: false, reason: REASON_PAGE_NOT_FOUND });
     }
+    /**
+     * 他のページ（`from`）の付箋を読んで、このページに置く。置き方は receiveNotes と同じ。
+     * 付箋の中身と作成者は、元のページの DO から読む（送る側の申告を使わない）。
+     * 元のページからは消さない（消すのは、置けた後に、Worker が removeNotes で行う）。
+     * 子ページを表す付箋は、置かずに断る（ページの親が変わることになる）
+     */
+    takeNotes(input) {
+        const pageNotFound = { ok: false, reason: REASON_PAGE_NOT_FOUND, notFound: true };
+        return this.write(async () => {
+            const { actor, clientId, opId, from, noteIds } = input;
+            if (this.version === 0)
+                return pageNotFound;
+            // 同じ操作の再送。元のページの付箋は、前の送信で消えていることがあるので、読みに行かない
+            const done = this.findOp(actor, clientId, opId);
+            if (done) {
+                const noteIds = createdNoteIds(JSON.parse(done.body));
+                return { ok: true, seq: done.seq, noteIds, versions: null };
+            }
+            if (from === this.slug())
+                return { ok: false, reason: 'cannot move notes to the same page' };
+            // 元のページの読み取りは、向こうの順番待ちに入らない。向こうの書き込みが、こちらの順番待ちを
+            // 待っていることがあるため（入ると、互いに待って止まる）。読んだ後に向こうで変わった付箋は、
+            // removeNotes が版を比べて、消さずに残す
+            const source = await this.env.PAGE.getByName(from).notesAmong(noteIds);
+            if (!source)
+                return { ok: false, reason: `page not found: ${from}`, notFound: true };
+            return this.placeTaken(input, source);
+        }, pageNotFound);
+    }
+    /**
+     * 付箋 `ids` と、その付箋どうしをつなぐ接続線。他のページが、移す付箋を読む（takeNotes）。
+     * ページがまだ作られていなければ null
+     */
+    notesAmong(ids) {
+        return this.version === 0 ? null : readNotesAmong(this.sql, ids);
+    }
+    /** takeNotes で読んだ付箋を、新しい id にして置く */
+    async placeTaken(input, source) {
+        const { from, noteIds, positions, keepAuthors, summary, ...sender } = input;
+        const byId = new Map(source.notes.map((note) => [note.id, note]));
+        /** 元のページでの id から、このページでの id（同じ付箋を 2 回写しても、重ならない） */
+        const newIds = new Map();
+        const authors = new Map();
+        const versions = {};
+        const notes = [];
+        for (const id of noteIds) {
+            const found = byId.get(id);
+            if (!found)
+                return { ok: false, reason: `note not found: ${id}`, notFound: true };
+            if (childPageOf(found) !== undefined)
+                return { ok: false, reason: `cannot move a child page note: ${id}` };
+            const { createdBy, updatedAt, ...note } = found;
+            const newId = crypto.randomUUID();
+            newIds.set(id, newId);
+            notes.push({ ...note, ...positions.get(id), id: newId });
+            if (keepAuthors)
+                authors.set(newId, createdBy);
+            versions[id] = updatedAt;
+        }
+        // 読んだ接続線は、送る付箋どうしをつなぐものだけ（残る付箋との接続線は、置かない）
+        const edges = source.edges.map((edge) => ({
+            ...edge, id: crypto.randomUUID(), from: newIds.get(edge.from), to: newIds.get(edge.to),
+        }));
+        const result = await this.applyOpsInOrder({
+            ...sender,
+            deltas: [
+                ...notes.map((note) => ({ type: 'note:create', note })),
+                ...edges.map((edge) => ({ type: 'edge:create', edge })),
+            ],
+            summary: summary ?? systemSummary.notesReceived(from),
+            mustExist: true,
+        }, { prepare: (deltas) => this.placeBelowNotes(deltas), authors });
+        if (!result.ok)
+            return { ok: false, reason: result.reason };
+        return { ok: true, seq: result.seq, noteIds: createdNoteIds(result.deltas), versions };
+    }
+    /**
+     * 他のページへ移した付箋を、このページから消す（takeNotes で置けた後に、Worker が呼ぶ）。
+     * 付箋を読むのは、順番待ちに入ってから。同じ opId で送り直しても、二重には記録しない
+     */
+    removeNotes(input) {
+        return this.write(async () => {
+            const { noteIds, versions, to, summary, ...sender } = input;
+            if (this.version === 0)
+                return { ok: false, reason: REASON_PAGE_NOT_FOUND };
+            // 同じ操作の再送。付箋は前の送信で消えている
+            const done = this.findOp(sender.actor, sender.clientId, sender.opId);
+            if (done)
+                return { ok: true, seq: done.seq, kept: [] };
+            const current = new Map(readNotesAmong(this.sql, noteIds).notes.map((note) => [note.id, note]));
+            // 読んだ後に変わった付箋と、誰かが消した付箋（同時に別のページへ移した場合を含む）は消さない
+            const kept = versions ? noteIds.filter((id) => current.get(id)?.updatedAt !== versions[id]) : [];
+            const keptSet = new Set(kept);
+            const notes = [...current.values()]
+                .filter((note) => !keptSet.has(note.id))
+                .map(({ createdBy: _, updatedAt: __, ...note }) => note);
+            // 空のデルタは記録できない
+            if (notes.length === 0)
+                return { ok: true, seq: null, kept };
+            const result = await this.applyOpsInOrder({
+                ...sender,
+                deltas: notes.map((note) => ({ type: 'note:delete', note })),
+                summary: summary ?? systemSummary.notesSent(to),
+                mustExist: true,
+            });
+            if (!result.ok)
+                return { ok: false, reason: result.reason };
+            return { ok: true, seq: result.deltas.length > 0 ? result.seq : null, kept };
+        }, { ok: false, reason: REASON_PAGE_NOT_FOUND });
+    }
+    /** 作成のデルタの付箋を、互いの位置関係を保ったまま、今ある付箋の下へずらす */
+    placeBelowNotes(deltas) {
+        placeBelow(createdNotes(deltas), this.sql
+            .exec(`SELECT min(x) AS left, max(y + height) AS bottom FROM notes`)
+            .one());
+    }
     /** 前の書き込みが終わってから `run` を始める */
     inOrder(run) {
         const result = this.applyQueue.then(run);
@@ -809,11 +929,13 @@ export class PageDO extends DurableObject {
         return { seq, deliver };
     }
     /**
-     * @param prepare 検証の済んだデルタを、適用する前に書き換える（今あるボードに合わせた位置決めなど）。
+     * @param options.prepare 検証の済んだデルタを、適用する前に書き換える（今あるボードに合わせた位置決めなど）。
      *   同じ操作の再送（適用済み）では、呼ばない
-     * @param matchColors 適用した後に、子ページの色と、その付箋の色をそろえる（matchChildColors）
+     * @param options.matchColors 適用した後に、子ページの色と、その付箋の色をそろえる（matchChildColors）。既定は true
+     * @param options.authors 作成する付箋の作成者（付箋の id から）。applyDeltas を参照
      */
-    async applyOpsInOrder(input, prepare, matchColors = true) {
+    async applyOpsInOrder(input, options = {}) {
+        const { prepare, matchColors = true, authors } = options;
         let deltas;
         let sanitized;
         try {
@@ -848,7 +970,7 @@ export class PageDO extends DurableObject {
             try {
                 const result = this.ctx.storage.transactionSync(() => {
                     const now = Date.now();
-                    const applied = applyDeltas(this.sql, deltas, input.actor, now, sanitized.cleanBefore);
+                    const applied = applyDeltas(this.sql, deltas, input.actor, now, sanitized.cleanBefore, authors);
                     const fixups = [...sanitized.fixups, ...applied.fixups];
                     if (applied.deltas.length === 0) {
                         return { ok: true, seq: this.getSeq(), deltas: [], fixups, broadcast: false };

package/dist/lib/worker/pages-api.js

@@ -7,6 +7,7 @@ import { isValidSlug } from '../shared/slug';
 import { createFirstPage } from './first-page';
 import { REASON_PAGE_NOT_FOUND } from './page-do';
 import { listPages, searchPages, searchRoots } from './page-queries';
+import { transferNotes } from './transfer';
 const REVERT_STATUS = {
     'not-found': 404,
     conflict: 409,
@@ -199,10 +200,50 @@ pagesApi.post('/pages/:slug/ops/:seq/revert', validSlug, async (c) => {
         return c.json(result);
     return c.json({ error: result.reason }, REVERT_STATUS[result.code]);
 });
+const TRANSFER_STATUS = {
+    'not-found': 404,
+    invalid: 400,
+    partial: 409,
+};
+/**
+ * このページの付箋を、他のページ（`to`）へ移す（写す）。本文は
+ * `{ clientId, opId, to, noteIds, positions?, copy? }`。付箋の中身はサーバーが読む。
+ * 移すときは、作成者を引き継ぎ、このページから消す。写すときは、作成者は写した人になり、このページに残す。
+ * `positions`（付箋の id から `{ x, y }`）は、このページでの位置の代わりに使う（ドラッグで動かした
+ * 付箋を、動かす前の位置で送る）。送り先では、今ある付箋の下に置く。同じ `opId` で送り直しても、
+ * 二重には置かない。送り先がなければ 404（作らない）
+ */
+pagesApi.post('/pages/:slug/transfer', validSlug, async (c) => {
+    const body = await c.req
+        .json()
+        .catch(() => null);
+    const to = body?.to;
+    // スラッグの形は transferNotes が確かめる
+    if (typeof to !== 'string')
+        return c.json({ error: 'invalid to' }, 400);
+    const result = await transferNotes(c.env, {
+        actor: c.get('actor'),
+        clientId: String(body?.clientId ?? ''),
+        opId: String(body?.opId ?? ''),
+        from: c.req.param('slug'),
+        to,
+        noteIds: body?.noteIds,
+        positions: body?.positions,
+        copy: body?.copy === true,
+    });
+    if (!result.ok)
+        return c.json({ error: result.reason }, TRANSFER_STATUS[result.code]);
+    // 置いた後の送り先の概要も返す（送った側が、索引への反映を待たずに、子ページの付箋を描き直せる）
+    const summary = await c.env.PAGE.getByName(to).getSummary();
+    return c.json({ ok: true, page: summary && { name: to, ...summary } });
+});
 /**
  * 他のページから移す（写す）付箋を置く。本文は `{ clientId, opId, from, notes, edges }`
  * （`from` は、付箋が元あったページ。同じ `opId` で送り直しても、二重には置かない）。
- * 今ある付箋の下に置く。ページがなければ 404（作らない）
+ * 今ある付箋の下に置く。ページがなければ 404（作らない）。
+ *
+ * 付箋の中身を送る側が渡すので、作成者は送った人になる。今の画面は `/transfer` を使う。これは、
+ * 更新の前に開いた画面のタブのために残している
  */
 pagesApi.post('/pages/:slug/notes', validSlug, async (c) => {
     const body = await c.req

package/dist/lib/worker/transfer.d.ts

@@ -0,0 +1,39 @@
+import type { WemaKakeEnv } from './config';
+export interface TransferInput {
+    /** 変更の主体。呼び出し側が認証結果から決める */
+    actor: string;
+    clientId: string;
+    /** 同じ値で送り直しても、二重には置かない（消す操作も同じ値で記録する） */
+    opId: string;
+    from: string;
+    to: string;
+    /** 外から来た値をそのまま渡す。検証はここで行う */
+    noteIds: unknown;
+    /** 付箋の id から、元のページでの位置の代わりに使う `{ x, y }`。外から来た値 */
+    positions?: unknown;
+    /** 写す（元のページに残す。作成者は `actor`）。偽なら移す（作成者を引き継ぐ） */
+    copy: boolean;
+    /** 操作の履歴に出す説明。省略すると、相手のページを表す符号 */
+    summary?: string;
+}
+/**
+ * - `not-found`: 送り先か元のページ、または付箋がない
+ * - `invalid`: 入力が不正か、置けなかった
+ * - `partial`: 送り先には置けたが、元のページから消せなかった付箋がある（消せなかった、または
+ *   読んだ後に元のページで変わったか消えたので、消さなかった）
+ */
+export type TransferFailure = 'not-found' | 'invalid' | 'partial';
+export type TransferResult = {
+    ok: true;
+    /** 送り先に置いた付箋の id（`noteIds` と同じ順） */
+    noteIds: string[];
+    /** 送り先で記録した操作の番号 */
+    received: number;
+    /** 元のページで記録した操作の番号。写したとき、消す付箋がもうなかったときは null */
+    removed: number | null;
+} | {
+    ok: false;
+    code: TransferFailure;
+    reason: string;
+};
+export declare function transferNotes(env: WemaKakeEnv, input: TransferInput): Promise<TransferResult>;

package/dist/lib/worker/transfer.js

@@ -0,0 +1,51 @@
+import { isValidSlug } from '../shared/slug';
+import { parseId, parseNoteIds, parsePositions, RejectError } from './validate';
+/**
+ * 元のページから付箋を消す操作の clientId。送った画面の clientId を使うと、その画面は、自分の操作の
+ * 確定と見なして（覚えのない opId なので無視して）、消したことを手元に反映しない
+ */
+const REMOVE_CLIENT_ID = 'transfer';
+export async function transferNotes(env, input) {
+    const { actor, clientId, opId, from, to, copy, summary } = input;
+    let noteIds;
+    let positions;
+    try {
+        if (!isValidSlug(from) || !isValidSlug(to))
+            throw new RejectError('invalid page');
+        // 消す操作は別の clientId で記録するので、ここで確かめておく（送り先は、置く前に確かめる）
+        parseId(opId, 'opId');
+        noteIds = parseNoteIds(input.noteIds);
+        positions = parsePositions(input.positions);
+    }
+    catch (e) {
+        if (e instanceof RejectError)
+            return { ok: false, code: 'invalid', reason: e.message };
+        throw e;
+    }
+    const taken = await env.PAGE.getByName(to).takeNotes({
+        actor, clientId, opId, from, noteIds, positions, keepAuthors: !copy, summary,
+    });
+    if (!taken.ok)
+        return { ok: false, code: taken.notFound ? 'not-found' : 'invalid', reason: taken.reason };
+    if (copy)
+        return { ok: true, noteIds: taken.noteIds, received: taken.seq, removed: null };
+    const removed = await env.PAGE.getByName(from)
+        .removeNotes({ actor, clientId: REMOVE_CLIENT_ID, opId, noteIds, versions: taken.versions, to, summary })
+        .catch((e) => ({ ok: false, reason: e instanceof Error ? e.message : String(e) }));
+    if (!removed.ok) {
+        return {
+            ok: false,
+            code: 'partial',
+            reason: `placed the notes in ${to} (operation ${taken.seq}), but could not remove them from ${from}: ${removed.reason}`,
+        };
+    }
+    if (removed.kept.length > 0) {
+        return {
+            ok: false,
+            code: 'partial',
+            reason: `placed the notes in ${to} (operation ${taken.seq}), but left ${removed.kept.join(', ')} in ${from}` +
+                ` because they were changed or removed there while moving (the copies in ${to} are from before the change)`,
+        };
+    }
+    return { ok: true, noteIds: taken.noteIds, received: taken.seq, removed: removed.seq };
+}

package/dist/lib/worker/validate.d.ts

@@ -17,5 +17,12 @@ declare function id(v: unknown, what: string): string;
 export { id as parseId };
 /** 付箋の、id と zIndex 以外のフィールド */
 export type NoteField = Exclude<keyof WemaNote, 'id' | 'zIndex'>;
+/** 他のページへ移す（写す）付箋の id の一覧。重複は 1 つにする */
+export declare function parseNoteIds(input: unknown): string[];
+/** 付箋の id から、位置（`{ x, y }`）。省略されていれば空 */
+export declare function parsePositions(input: unknown): Map<string, {
+    x: number;
+    y: number;
+}>;
 /** 外から来たデルタの形を検証し、既知のフィールドだけを持つデルタにして返す */
 export declare function parseDeltas(input: unknown): HistoryDelta[];

package/dist/lib/worker/validate.js

@@ -193,6 +193,23 @@ function parseDelta(v) {
             throw new RejectError('unknown delta type');
     }
 }
+/** 他のページへ移す（写す）付箋の id の一覧。重複は 1 つにする */
+export function parseNoteIds(input) {
+    if (!Array.isArray(input) || input.length === 0)
+        throw new RejectError('invalid noteIds');
+    if (input.length > MAX_DELTAS)
+        throw new RejectError(`too many notes (${input.length}, limit ${MAX_DELTAS})`);
+    return [...new Set(input.map((v) => id(v, 'note id')))];
+}
+/** 付箋の id から、位置（`{ x, y }`）。省略されていれば空 */
+export function parsePositions(input) {
+    if (input === undefined || input === null)
+        return new Map();
+    return new Map(Object.entries(obj(input, 'positions')).map(([key, v]) => {
+        const p = obj(v, 'position');
+        return [id(key, 'note id'), { x: num(p.x, 'x'), y: num(p.y, 'y') }];
+    }));
+}
 /** 外から来たデルタの形を検証し、既知のフィールドだけを持つデルタにして返す */
 export function parseDeltas(input) {
     if (!Array.isArray(input) || input.length === 0)