@lapis-notes/api 0.1.3 → 0.2.0

package/dist/__tests__/fixtures/task-projection.json

@@ -0,0 +1,428 @@
+{
+  "records": [
+    {
+      "documentPath": "tasks/full.md",
+      "documentId": "full",
+      "kind": "task",
+      "title": "Full task",
+      "status": "open",
+      "inbox": false,
+      "startKind": "anytime",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0,
+      "priority": "high",
+      "startDate": null,
+      "planDate": "2026-10-24",
+      "planKind": "time",
+      "planTime": "09:30",
+      "durationMinutes": 45.0,
+      "deadline": "2026-10-30",
+      "completedAt": null,
+      "repeat": {
+        "start": "2026-10-01",
+        "rrule": "FREQ=WEEKLY;BYDAY=MO,FR",
+        "anchor": "schedule",
+        "missed": "carry",
+        "rdate": ["2026-11-01"],
+        "exdate": ["2026-11-02"],
+        "resetChecklist": true,
+        "paused": false,
+        "pausedSince": "2026-10-02",
+        "pauseRanges": [
+          {
+            "start": "2026-10-02",
+            "end": "2026-10-03"
+          }
+        ],
+        "lastCompletedAt": "2026-10-20T12:00:00Z",
+        "completionCount": 3.0
+      },
+      "tracking": {
+        "type": "count",
+        "unit": "pages",
+        "target": 20.0
+      },
+      "effectiveOccurrenceDate": "2026-10-24",
+      "effectiveOccurrenceState": "current",
+      "effectiveForDate": "2026-10-24",
+      "repeatStrategy": null,
+      "repeatFrequency": "weekly",
+      "repeatInterval": 2.0,
+      "repeatAnchor": "schedule",
+      "structure": {
+        "version": 1.0,
+        "sourceHash": "hash",
+        "entries": [
+          {
+            "sourceDocumentId": "full",
+            "sourceDocumentPath": "tasks/full.md",
+            "targetDocumentId": "child",
+            "targetDocumentPath": "tasks/child.md",
+            "kind": "task-entry",
+            "headingPath": ["Tasks"],
+            "headingLevel": 2.0,
+            "headingText": "Tasks",
+            "runId": "run",
+            "positionInRun": 0.0,
+            "sourceStart": 10.0,
+            "sourceEnd": 30.0,
+            "authoredLabel": "Child",
+            "authoredHref": "child.md"
+          }
+        ],
+        "runs": [
+          {
+            "id": "run",
+            "documentId": "full",
+            "documentPath": "tasks/full.md",
+            "headingPath": ["Tasks"],
+            "headingLevel": null,
+            "headingText": null,
+            "listDepth": 0.0,
+            "startOffset": 10.0,
+            "endOffset": 30.0,
+            "entryCount": 1.0
+          }
+        ],
+        "diagnostics": [
+          {
+            "code": "sample",
+            "message": "retained",
+            "sourceStart": 10.0,
+            "sourceEnd": 30.0,
+            "target": "child"
+          }
+        ]
+      }
+    },
+    {
+      "documentPath": "tasks/inbox.md",
+      "documentId": "inbox",
+      "kind": "task",
+      "title": "inbox",
+      "status": "open",
+      "inbox": true,
+      "startKind": "anytime",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0
+    },
+    {
+      "documentPath": "tasks/overdue.md",
+      "documentId": "overdue",
+      "kind": "task",
+      "title": "overdue",
+      "status": "open",
+      "inbox": false,
+      "startKind": "anytime",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0,
+      "planDate": "2026-10-01",
+      "effectiveOccurrenceState": "overdue",
+      "effectiveOccurrenceDate": "2026-10-23",
+      "effectiveForDate": "2026-10-24"
+    },
+    {
+      "documentPath": "tasks/future.md",
+      "documentId": "future",
+      "kind": "task",
+      "title": "future",
+      "status": "open",
+      "inbox": false,
+      "startKind": "anytime",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0,
+      "planDate": "2026-10-01",
+      "effectiveOccurrenceState": "future",
+      "effectiveOccurrenceDate": "2026-10-26",
+      "effectiveForDate": "2026-10-24"
+    },
+    {
+      "documentPath": "tasks/carried.md",
+      "documentId": "carried",
+      "kind": "task",
+      "title": "carried",
+      "status": "open",
+      "inbox": false,
+      "startKind": "date",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0,
+      "planDate": "2026-10-20",
+      "startDate": "2026-10-01"
+    },
+    {
+      "documentPath": "tasks/someday.md",
+      "documentId": "someday",
+      "kind": "task",
+      "title": "someday",
+      "status": "open",
+      "inbox": false,
+      "startKind": "someday",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0
+    },
+    {
+      "documentPath": "tasks/completed.md",
+      "documentId": "completed",
+      "kind": "task",
+      "title": "completed",
+      "status": "completed",
+      "inbox": false,
+      "startKind": "anytime",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0,
+      "completedAt": "2026-10-22"
+    },
+    {
+      "documentPath": "tasks/list.md",
+      "documentId": "list",
+      "kind": "task-list",
+      "title": "list",
+      "status": "active",
+      "inbox": false,
+      "startKind": "anytime",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0
+    },
+    {
+      "documentPath": "tasks/deadline.md",
+      "documentId": "deadline",
+      "kind": "task",
+      "title": "deadline",
+      "status": "open",
+      "inbox": false,
+      "startKind": "date",
+      "checklistTotal": 4.0,
+      "checklistCompleted": 1.0,
+      "commentCount": 2.0,
+      "projectionVersion": 4.0,
+      "deadline": "2026-10-23",
+      "startDate": "2026-10-30"
+    }
+  ],
+  "cases": [
+    {
+      "query": {
+        "view": "inbox",
+        "today": "2026-10-24"
+      },
+      "ids": ["inbox"]
+    },
+    {
+      "query": {
+        "view": "today",
+        "today": "2026-10-24"
+      },
+      "ids": ["carried", "deadline", "full"]
+    },
+    {
+      "query": {
+        "view": "anytime",
+        "today": "2026-10-24"
+      },
+      "ids": ["inbox"]
+    },
+    {
+      "query": {
+        "view": "upcoming",
+        "today": "2026-10-24"
+      },
+      "ids": ["deadline", "full", "future"]
+    },
+    {
+      "query": {
+        "view": "someday",
+        "today": "2026-10-24"
+      },
+      "ids": ["someday"]
+    },
+    {
+      "query": {
+        "view": "completed",
+        "today": "2026-10-24"
+      },
+      "ids": ["completed"]
+    },
+    {
+      "query": {
+        "view": "review",
+        "today": "2026-10-24"
+      },
+      "ids": ["carried", "overdue"]
+    },
+    {
+      "query": {
+        "documentId": "full"
+      },
+      "ids": ["full"]
+    },
+    {
+      "query": {
+        "documentPath": "tasks/full.md",
+        "kind": "task"
+      },
+      "ids": ["full"]
+    },
+    {
+      "query": {
+        "kind": "task-list"
+      },
+      "ids": ["list"]
+    },
+    {
+      "query": {
+        "view": "today",
+        "today": "2026-10-24",
+        "limit": 1
+      },
+      "ids": ["carried"]
+    }
+  ],
+  "fields": {
+    "documentPath": {
+      "type": "path",
+      "indexed": true,
+      "sortable": true
+    },
+    "documentId": {
+      "type": "string",
+      "indexed": true,
+      "unique": true
+    },
+    "kind": {
+      "type": "string",
+      "indexed": true
+    },
+    "title": {
+      "type": "string",
+      "indexed": true,
+      "sortable": true
+    },
+    "status": {
+      "type": "string",
+      "indexed": true,
+      "sortable": true
+    },
+    "priority": {
+      "type": "string",
+      "indexed": true,
+      "sortable": true
+    },
+    "inbox": {
+      "type": "boolean",
+      "indexed": true
+    },
+    "startKind": {
+      "type": "string",
+      "indexed": true
+    },
+    "startDate": {
+      "type": "date",
+      "indexed": true,
+      "sortable": true
+    },
+    "planDate": {
+      "type": "date",
+      "indexed": true,
+      "sortable": true
+    },
+    "planKind": {
+      "type": "string",
+      "indexed": true
+    },
+    "planTime": {
+      "type": "string",
+      "indexed": true,
+      "sortable": true
+    },
+    "durationMinutes": {
+      "type": "number",
+      "indexed": true,
+      "sortable": true
+    },
+    "deadline": {
+      "type": "date",
+      "indexed": true,
+      "sortable": true
+    },
+    "completedAt": {
+      "type": "string",
+      "indexed": true
+    },
+    "repeat": {
+      "type": "json"
+    },
+    "repeatStart": {
+      "type": "date",
+      "indexed": true,
+      "sortable": true
+    },
+    "repeatRRule": {
+      "type": "string",
+      "indexed": true
+    },
+    "repeatAnchor": {
+      "type": "string",
+      "indexed": true
+    },
+    "repeatMissed": {
+      "type": "string",
+      "indexed": true
+    },
+    "repeatPaused": {
+      "type": "boolean",
+      "indexed": true
+    },
+    "repeatPausedSince": {
+      "type": "date",
+      "indexed": true,
+      "sortable": true
+    },
+    "tracking": {
+      "type": "json"
+    },
+    "effectiveOccurrenceDate": {
+      "type": "date",
+      "indexed": true,
+      "sortable": true
+    },
+    "effectiveOccurrenceState": {
+      "type": "string",
+      "indexed": true,
+      "sortable": true
+    },
+    "effectiveForDate": {
+      "type": "date",
+      "indexed": true,
+      "sortable": true
+    },
+    "checklistTotal": {
+      "type": "number"
+    },
+    "checklistCompleted": {
+      "type": "number"
+    },
+    "commentCount": {
+      "type": "number",
+      "indexed": true
+    },
+    "structure": {
+      "type": "json"
+    }
+  }
+}

package/dist/__tests__/indexed-mutation-support.js

@@ -0,0 +1,262 @@
+import { connect } from "@tursodatabase/database";
+import { TursoAppDatabase, } from "../storage/turso-app-database";
+import tasks from "./fixtures/task-projection.json";
+export const oldPath = "Notes/Öld.md";
+export const newPath = "Archive/新.md";
+export const refPath = "Links.md";
+export function record(path, task = false) {
+    return {
+        file: {
+            path,
+            normalizedPath: path,
+            extension: ".MD",
+            mtime: 1,
+            size: 12,
+            hash: "hash-1",
+            indexed: true,
+        },
+        metadata: {
+            path,
+            hash: "hash-1",
+            parserVersion: "fixture",
+            metadata: { title: "Fixture 🪨" },
+        },
+        links: [
+            {
+                sourcePath: path,
+                targetText: "Old",
+                resolvedTargetPath: path === refPath ? oldPath : refPath,
+                type: "link",
+                count: 1,
+                kind: "reference",
+            },
+        ],
+        tags: [
+            {
+                path,
+                tag: "#Work/Notes",
+                parts: ["Work", "Notes"],
+                hierarchy: ["Work", "Work/Notes"],
+            },
+        ],
+        properties: [{ path, name: "Score", inferredType: "number", value: 1 }],
+        ...(task
+            ? {
+                task: {
+                    ...tasks.records[0],
+                    documentPath: path,
+                },
+            }
+            : {}),
+    };
+}
+export function scenarios() {
+    const changed = record(oldPath);
+    changed.file.hash = changed.metadata.hash = "changed";
+    changed.properties[0].value = 2;
+    const updated = record(oldPath, true);
+    updated.task.title = "Updated task";
+    return [
+        {
+            name: "omitted task preserves task",
+            steps: [{ kind: "upsert", record: changed }],
+        },
+        {
+            name: "task record updates stages",
+            steps: [{ kind: "upsert", record: updated }],
+        },
+        {
+            name: "null task removes only task projection",
+            steps: [{ kind: "upsert", record: { ...record(oldPath), task: null } }],
+        },
+        {
+            name: "rename all source domains and incoming references",
+            steps: [{ kind: "rename", oldPath, newPath }],
+        },
+        {
+            name: "delete all source-owned domains",
+            steps: [{ kind: "delete", path: oldPath }],
+        },
+        {
+            name: "missing rename is a no-op",
+            steps: [{ kind: "rename", oldPath: "Missing.md", newPath }],
+        },
+        {
+            name: "missing delete still commits domains",
+            steps: [{ kind: "delete", path: "Missing.md" }],
+        },
+        {
+            name: "rename then delete",
+            steps: [
+                { kind: "rename", oldPath, newPath },
+                { kind: "delete", path: newPath },
+            ],
+        },
+        {
+            name: "rename projection collision rolls back",
+            collision: true,
+            steps: [{ kind: "rename", oldPath, newPath }],
+        },
+        {
+            name: "same-path rename retains data",
+            steps: [{ kind: "rename", oldPath, newPath: oldPath }],
+        },
+    ];
+}
+export function seedInputs(collision = false) {
+    return {
+        indexed: [
+            record(oldPath, true),
+            record(refPath),
+            ...(collision ? [record(newPath)] : []),
+        ],
+        notebook: {
+            sourcePath: oldPath,
+            mtime: 1,
+            updatedAt: 2,
+            cells: {
+                a: {
+                    state: "complete",
+                    outputs: [{ kind: "text", value: "retained" }],
+                },
+            },
+        },
+        search: {
+            path: oldPath,
+            name: "Original",
+            extension: "md",
+            checksum: "hash-1",
+            content: "Retained search 🪨",
+            tags: ["work"],
+            tagParts: ["work"],
+            tagHierarchy: ["work"],
+            chunks: [
+                {
+                    id: `${oldPath}#main`,
+                    text: "Retained search 🪨",
+                    startOffset: 0,
+                    endOffset: 18,
+                    embedding: {
+                        status: "ready",
+                        modelId: "fixture",
+                        vector: [1, 0],
+                        dimensions: 2,
+                        updatedAt: 2,
+                    },
+                },
+            ],
+        },
+        definition: {
+            projectionId: "fixture/items",
+            ownerPluginId: "fixture",
+            schemaVersion: 1,
+            configHash: "fixture-1",
+            visibility: "public",
+            fields: { label: { type: "string", sortable: true } },
+            active: true,
+            updatedAt: 1,
+        },
+        sources: [
+            [oldPath, "main"],
+            [refPath, "ref"],
+            ...(collision ? [[newPath, "destination"]] : []),
+        ].map(([path, id]) => ({
+            projectionId: "fixture/items",
+            sourcePath: path,
+            sourceHash: "hash-1",
+            rows: [{ id, kind: "item", data: { label: id } }],
+            edges: id === "ref"
+                ? [
+                    {
+                        sourceRowId: id,
+                        relation: "reference",
+                        targetPath: oldPath,
+                        ordinal: 0,
+                    },
+                ]
+                : [],
+        })),
+    };
+}
+export async function seed(db, input) {
+    for (const row of input.indexed)
+        await db.upsertIndexedFile(row);
+    await db.setNotebookState(input.notebook.sourcePath, input.notebook);
+    await db.upsertSearchDocument(input.search);
+    await db.registerProjectionDefinition(input.definition);
+    for (const row of input.sources)
+        await db.replaceProjectionSource(row);
+}
+export async function database(collision = false) {
+    const db = new TursoAppDatabase("indexed-mutations", {
+        kind: "turso-native",
+        transport: "native",
+        connectionFactory: async () => (await connect(":memory:", {
+            experimental: ["index_method"],
+        })),
+    });
+    await db.open();
+    await seed(db, seedInputs(collision));
+    return db;
+}
+export async function snapshot(db) {
+    const paths = await Promise.all([oldPath, newPath, refPath].map(async (path) => ({
+        path,
+        indexed: (await db.getIndexedFile(path)) ?? null,
+        notebook: (await db.getNotebookState(path)) ?? null,
+        task: (await db.getTaskRow({ path })) ?? null,
+        search: (await db.getSearchDocument(path)) ?? null,
+        incoming: await db.queryMetadataLinks({ direction: "incoming", path }),
+    })));
+    return JSON.parse(JSON.stringify({
+        paths,
+        manifest: await db.listIndexedFileManifest(),
+        searchManifest: await db.listSearchDocumentManifest(),
+        searchStats: await db.getSearchIndexStats(),
+        projection: await db.queryProjection("fixture/items", {
+            orderBy: [{ field: "id" }],
+        }),
+        stale: await db.queryProjection("fixture/items", {
+            includeStale: true,
+            orderBy: [{ field: "id" }],
+        }),
+        related: await db.queryRelated({
+            projectionId: "fixture/items",
+            rowId: "ref",
+            relation: "reference",
+        }),
+        revision: await db.getChangeRevision(),
+    }));
+}
+export async function run(db, steps) {
+    const before = await db.getChangeRevision();
+    const events = [];
+    const release = db.subscribeToChanges((change) => events.push({
+        revision: change.revision - before,
+        domains: change.domains,
+        paths: change.paths ?? [],
+        renamed: change.renamed ?? null,
+    }));
+    const states = [];
+    try {
+        for (const step of steps) {
+            let failed = false;
+            try {
+                if (step.kind === "upsert")
+                    await db.upsertIndexedFile(step.record);
+                else if (step.kind === "rename")
+                    await db.renameIndexedFile(step.oldPath, step.newPath);
+                else
+                    await db.deleteIndexedFile(step.path);
+            }
+            catch {
+                failed = true;
+            }
+            states.push({ failed, state: await snapshot(db) });
+        }
+        return { events, states };
+    }
+    finally {
+        release();
+    }
+}