@wirecat/cli-core 0.419.0 → 0.421.0

package/dist/store/sqlite/notes.js

@@ -1,14 +1,17 @@
 import { CliError } from "@wirecat/cli-base";
 import { MAX_TEXT_CHARS } from "../../attachments/limits.js";
 import { googleDocumentLinks } from "../../domain/google-documents.js";
+import { DOCUMENT_ACCOUNT_PROVIDERS, filesAccountSql, folderProviderOf, folderProviderSql, isDocumentAccountProvider, } from "../../domain/providers.js";
 import { parseReference } from "../../domain/references.js";
 import { normalizeTag } from "../../domain/tags.js";
 import { fold } from "../normalize.js";
 import { ulid } from "../ulid.js";
 import { ownerPerson } from "./actors.js";
 import { encodeDocumentMetadata, languageOf } from "./document-metadata.js";
+import { PREFERRED_FILE, syncFile } from "./files.js";
 import { importedDocumentWhere } from "./imported-documents.js";
 import { LINK_KINDS, linkKind } from "./link-kinds.js";
+import { reviewLink } from "./link-reviews.js";
 import { addTags, ensureTag, labelsOf } from "./tags.js";
 import { canonicalThingReference, referenceOfThing, storedThing, thingOf } from "./things.js";
 import { write } from "./transaction.js";
@@ -177,13 +180,33 @@ export const insertLink = (context, input) => {
 /** A folder's `accounts` row; its format lives in `settings`. */
 const folderOf = (row) => {
     const settings = row.settings == null ? {} : JSON.parse(String(row.settings));
+    const folder = !isDocumentAccountProvider(String(row.provider));
     return {
         id: String(row.id),
-        name: String(row.name),
-        format: (settings.format ?? "obsidian"),
+        name: folder ? String(row.name) : `${String(row.provider)}:${String(row.external_id)}`,
+        provider: String(row.provider),
+        format: (settings.format ?? (folder ? "obsidian" : "markdown")),
         createdAt: iso(row.created_at),
+        ...(folder ? {} : { account: { provider: String(row.provider), account: String(row.external_id) } }),
     };
 };
+const frontMatterObject = (text) => {
+    try {
+        const value = JSON.parse(String(text));
+        return value !== null && typeof value === "object" ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const frontMatterOf = (metadata) => {
+    try {
+        return JSON.parse(String(metadata))?.front_matter ?? null;
+    }
+    catch {
+        return null;
+    }
+};
 const pathParts = (path) => {
     const slash = path.lastIndexOf("/");
     const fileName = slash < 0 ? path : path.slice(slash + 1);
@@ -198,7 +221,7 @@ export const notesStoreOver = (context) => {
     const { database, now } = context;
     const folderRow = (id) => {
         const row = /^\d+$/.test(id)
-            ? database.prepare("SELECT * FROM accounts WHERE id = ? AND provider = 'folder'").get(Number(id))
+            ? database.prepare(`SELECT * FROM accounts WHERE id = ? AND ${filesAccountSql()}`).get(Number(id))
             : undefined;
         if (!row)
             throw new CliError("not_found", `no notes folder ${id} in the local store`);
@@ -228,15 +251,101 @@ export const notesStoreOver = (context) => {
         return { limit, offset };
     };
     const documentTags = (id) => labelsOf(database, { type: "document", id });
+    /** A file row of a folder by its path; a local folder's own rows are not notes. */
+    const fileAt = (folder, path, liveOnly = false) => database
+        .prepare(`SELECT * FROM files WHERE account_id = ? AND external_id = ? AND kind <> 'folder'${liveOnly ? " AND deleted_at IS NULL" : ""}`)
+        .get(folder, path);
+    const isLocal = (accountId) => database
+        .prepare(`SELECT 1 FROM accounts WHERE id = ? AND provider IN ('local', 'obsidian')`)
+        .get(Number(accountId)) !== undefined;
+    /** Drive's documents are found by its folder and `<id>.md`, whichever account that folder is now. */
+    const remoteDocument = (row) => {
+        const front = frontMatterObject(row.front_matter);
+        return front?.source === "google-drive" || frontMatterObject(row.metadata)?.catalog !== undefined;
+    };
+    /** Drive's own saves keep their documents by folder and `<id>.md`; only files on disk join by content. */
+    const localSave = (folder, frontMatter) => isLocal(folder) && frontMatter?.source !== "google-drive";
+    /**
+     * The documents whose shown file has this content: live ones, else gone ones no file holds any more, so a file
+     * moved to another folder is the same document whichever folder syncs first. Empty text matches nothing.
+     */
+    const sameContent = (hash, text) => {
+        if (!hash || !text.trim())
+            return [];
+        const live = database
+            .prepare("SELECT id FROM documents WHERE content_hash = ? AND deleted_at IS NULL ORDER BY id")
+            .all(hash);
+        if (live.length)
+            return live.map(({ id }) => Number(id));
+        return database
+            .prepare("SELECT d.id FROM documents d WHERE d.content_hash = ? AND d.deleted_at IS NOT NULL AND NOT EXISTS " +
+            "(SELECT 1 FROM files f WHERE f.document_id = d.id AND f.deleted_at IS NULL) ORDER BY d.id")
+            .all(hash)
+            .map(({ id }) => Number(id));
+    };
+    /**
+     * A local document's own place columns follow the file it shows (the owner's pin, else the latest changed), so
+     * readers that still go by `documents.account_id` find it where it is. Drive's documents keep theirs.
+     */
+    const followPreferred = (id, at) => {
+        const document = documentRow(String(id));
+        if (!isLocal(document.account_id) || remoteDocument(document))
+            return;
+        const preferred = database
+            .prepare(`SELECT f.account_id, f.external_id FROM files f JOIN documents d ON d.id = f.document_id
+          JOIN accounts a ON a.id = f.account_id WHERE f.document_id = ? AND f.deleted_at IS NULL AND f.kind <> 'folder'
+          AND a.provider IN ('local', 'obsidian') ORDER BY ${PREFERRED_FILE} LIMIT 1`)
+            .get(id);
+        if (!preferred)
+            return;
+        const [account, path] = [Number(preferred.account_id), String(preferred.external_id)];
+        if (Number(document.account_id) === account && String(document.external_id) === path)
+            return;
+        const blocking = database
+            .prepare("SELECT id, deleted_at FROM documents WHERE account_id = ? AND external_id = ? AND id <> ?")
+            .get(account, path, id);
+        if (blocking?.deleted_at == null && blocking !== undefined)
+            return;
+        if (blocking)
+            database.prepare("DELETE FROM documents WHERE id = ?").run(Number(blocking.id));
+        const { location, fileName, extension } = pathParts(path);
+        database
+            .prepare("UPDATE documents SET account_id = ?, external_id = ?, location = ?, file_name = ?, extension = ?, updated_at = ? WHERE id = ?")
+            .run(account, path, location, fileName, extension, at, id);
+    };
+    /** The document as the folder that holds this file sees it: its folder and path are the file's. */
+    const noteAt = (id, folder, path) => ({
+        ...documentOf(documentRow(String(id))),
+        folderId: String(folder),
+        path,
+    });
     return {
         addFolder: async ({ name, format = "obsidian" }) => {
             const at = now();
+            const checked = oneOf(format, NOTE_FORMATS, "a folder's format");
             const row = database
-                .prepare("INSERT INTO accounts (provider, external_id, name, settings, created_at, updated_at) VALUES ('folder', ?, ?, ?, ?, ?) RETURNING id")
-                .get(ulid(at), textOf(name, "a folder's name", 200), JSON.stringify({ format: oneOf(format, NOTE_FORMATS, "a folder's format") }), at, at);
+                .prepare("INSERT INTO accounts (provider, external_id, name, settings, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?) RETURNING id")
+                .get(folderProviderOf(checked), ulid(at), textOf(name, "a folder's name", 200), JSON.stringify({ format: checked }), at, at);
             return folderOf(folderRow(String(row?.id)));
         },
-        folders: async () => database.prepare("SELECT * FROM accounts WHERE provider = 'folder' ORDER BY name, id").all().map(folderOf),
+        folders: async () => database.prepare(`SELECT * FROM accounts WHERE ${folderProviderSql()} ORDER BY name, id`).all().map(folderOf),
+        documentsAccount: async ({ provider, account }, create = false) => {
+            if (!isDocumentAccountProvider(provider))
+                throw new CliError("validation_error", `${provider} is not a provider whose accounts hold documents`);
+            const find = () => database.prepare("SELECT * FROM accounts WHERE provider = ? AND external_id = ?").get(provider, account);
+            const found = find();
+            if (found || !create)
+                return found ? folderOf(found) : undefined;
+            const at = now();
+            database
+                .prepare("INSERT OR IGNORE INTO accounts (provider, external_id, name, settings, created_at, updated_at) VALUES (?, ?, NULL, ?, ?, ?)")
+                .run(provider, textOf(account, "an account's id", 200), JSON.stringify({ format: "markdown" }), at, at);
+            return folderOf(find());
+        },
+        documentsAccounts: async () => database
+            .prepare(`SELECT * FROM accounts WHERE provider IN (${DOCUMENT_ACCOUNT_PROVIDERS.map(() => "?").join(", ")}) ORDER BY provider, external_id`)
+            .all(...DOCUMENT_ACCOUNT_PROVIDERS)
+            .map(folderOf),
         saveFileNote: async (input) => write(database, () => {
             const folder = Number(folderRow(input.folderId).id);
             const path = textOf(input.path, "a note's path", 4096);
@@ -246,9 +355,25 @@ export const notesStoreOver = (context) => {
             const language = languageOf(input.metadata);
             const title = typeof input.metadata?.title === "string" && input.metadata.title ? input.metadata.title : input.title;
             const at = now();
-            const found = database
-                .prepare("SELECT * FROM documents WHERE account_id = ? AND external_id = ?")
-                .get(folder, path);
+            const hash = input.contentHash ?? null;
+            const here = { accountId: folder, path, contentHash: hash, frontMatter: input.frontMatter ?? null };
+            const place = fileAt(folder, path);
+            const found = place?.document_id != null
+                ? documentRow(String(place.document_id))
+                : database.prepare("SELECT * FROM documents WHERE account_id = ? AND external_id = ?").get(folder, path);
+            // Rule 2 (requirements 3.3): a new local file with the content of exactly one document is a copy of it.
+            const candidates = !found && !place && localSave(folder, input.frontMatter) ? sameContent(hash, text) : [];
+            if (candidates.length === 1) {
+                const id = candidates[0];
+                const joined = documentRow(String(id));
+                if (joined.deleted_at != null)
+                    database
+                        .prepare("UPDATE documents SET deleted_at = NULL, body = ?, updated_at = ? WHERE id = ?")
+                        .run(text, at, id);
+                syncFile(database, at, id, { place: here, method: "content-hash" });
+                followPreferred(id, at);
+                return { note: noteAt(id, folder, path), changed: true };
+            }
             if (found?.metadata != null) {
                 const stored = JSON.parse(String(found.metadata));
                 if (stored.catalog !== undefined)
@@ -260,52 +385,117 @@ export const notesStoreOver = (context) => {
                     .prepare("INSERT INTO documents (account_id, external_id, kind, title, location, file_name, extension, storage, content_hash, " +
                     "front_matter, body, extraction, metadata, language, revision, created_at, updated_at) " +
                     "VALUES (?, ?, 'file', ?, ?, ?, ?, 'local', ?, ?, ?, 'text', ?, ?, 1, ?, ?) RETURNING id")
-                    .get(folder, path, title, location, fileName, extension, input.contentHash ?? null, frontMatter, text, metadata, language, at, at);
-                return { note: documentOf(documentRow(String(row?.id))), changed: true };
+                    .get(folder, path, title, location, fileName, extension, hash, frontMatter, text, metadata, language, at, at);
+                const id = Number(row?.id);
+                const file = syncFile(database, at, id);
+                if (candidates.length > 1 && file)
+                    reviewLink(database, { type: "file", id: file.id }, "document", candidates, "content-hash", at);
+                return { note: noteAt(id, folder, path), changed: true };
             }
+            const id = Number(found.id);
+            const own = Number(found.account_id) === folder && String(found.external_id) === path;
+            // A copy elsewhere changes the document's text; its own front matter stays on its file row.
+            const keptFrontMatter = own ? frontMatter : found.front_matter == null ? null : String(found.front_matter);
+            const keptMetadata = own ? metadata : found.metadata == null ? null : String(found.metadata);
             const same = (found.body ?? "") === text &&
                 (found.title ?? null) === title &&
-                (found.front_matter ?? null) === frontMatter &&
-                (found.metadata ?? null) === metadata &&
-                (found.content_hash ?? null) === (input.contentHash ?? null) &&
+                (found.front_matter ?? null) === keptFrontMatter &&
+                (found.metadata ?? null) === keptMetadata &&
+                (found.content_hash ?? null) === hash &&
                 found.deleted_at == null;
-            if (same)
-                return { note: documentOf(found), changed: false };
-            if ((found.body ?? "") !== text)
+            if (!same) {
+                if ((found.body ?? "") !== text)
+                    database
+                        .prepare("INSERT INTO document_revisions (document_id, body, revision, created_at) VALUES (?, ?, ?, ?)")
+                        .run(id, String(found.body ?? ""), Number(found.revision), at);
                 database
-                    .prepare("INSERT INTO document_revisions (document_id, body, revision, created_at) VALUES (?, ?, ?, ?)")
-                    .run(Number(found.id), String(found.body ?? ""), Number(found.revision), at);
-            database
-                .prepare("UPDATE documents SET title = ?, body = ?, front_matter = ?, content_hash = ?, metadata = ?, language = ?, " +
-                "revision = revision + ?, updated_at = ?, deleted_at = NULL WHERE id = ?")
-                .run(title, text, frontMatter, input.contentHash ?? null, metadata, language, (found.body ?? "") === text ? 0 : 1, at, Number(found.id));
-            return { note: documentOf(documentRow(String(found.id))), changed: true };
+                    .prepare("UPDATE documents SET title = ?, body = ?, front_matter = ?, content_hash = ?, metadata = ?, language = ?, " +
+                    "revision = revision + ?, updated_at = ?, deleted_at = NULL WHERE id = ?")
+                    .run(title, text, keptFrontMatter, hash, keptMetadata, language, (found.body ?? "") === text ? 0 : 1, at, id);
+            }
+            syncFile(database, at, id, own ? {} : { place: here });
+            if (!same)
+                followPreferred(id, at);
+            return { note: noteAt(id, folder, path), changed: !same };
         }),
         renameFileNote: async (folderId, from, to) => write(database, () => {
             const folder = Number(folderRow(folderId).id);
             const target = textOf(to, "a note's path", 4096);
-            const found = database
+            const at = now();
+            const place = fileAt(folder, from, true);
+            const legacy = database
                 .prepare("SELECT id FROM documents WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL")
                 .get(folder, from);
-            if (!found)
+            const id = place?.document_id != null ? Number(place.document_id) : legacy ? Number(legacy.id) : undefined;
+            if (id === undefined)
                 throw new CliError("not_found", `no live note at ${from} in folder ${folderId}`);
+            const takenFile = fileAt(folder, target);
+            if (takenFile?.deleted_at == null && takenFile !== undefined)
+                throw new CliError("validation_error", `a live note is already at ${target} in folder ${folderId}`);
             const taken = database
-                .prepare("SELECT id, deleted_at FROM documents WHERE account_id = ? AND external_id = ?")
-                .get(folder, target);
+                .prepare("SELECT id, deleted_at FROM documents WHERE account_id = ? AND external_id = ? AND id <> ?")
+                .get(folder, target, id);
             if (taken && taken.deleted_at == null)
                 throw new CliError("validation_error", `a live note is already at ${target} in folder ${folderId}`);
+            // The gone note at the target goes, as it always did; its file row goes with it or on its own.
             if (taken)
                 database.prepare("DELETE FROM documents WHERE id = ?").run(Number(taken.id));
-            const { location, fileName, extension } = pathParts(target);
-            database
-                .prepare("UPDATE documents SET external_id = ?, location = ?, file_name = ?, extension = ?, updated_at = ? WHERE id = ?")
-                .run(target, location, fileName, extension, now(), Number(found.id));
-            return documentOf(documentRow(String(found.id)));
+            if (takenFile)
+                database.prepare("DELETE FROM files WHERE id = ?").run(Number(takenFile.id));
+            if (place)
+                database.prepare("UPDATE files SET external_id = ? WHERE id = ?").run(target, Number(place.id));
+            const document = documentRow(String(id));
+            const own = Number(document.account_id) === folder && String(document.external_id) === from;
+            if (own) {
+                const { location, fileName, extension } = pathParts(target);
+                database
+                    .prepare("UPDATE documents SET external_id = ?, location = ?, file_name = ?, extension = ?, updated_at = ? WHERE id = ?")
+                    .run(target, location, fileName, extension, at, id);
+                syncFile(database, at, id);
+            }
+            else
+                syncFile(database, at, id, {
+                    place: {
+                        accountId: folder,
+                        path: target,
+                        contentHash: place?.content_hash == null ? null : String(place.content_hash),
+                        frontMatter: frontMatterOf(place?.metadata),
+                    },
+                });
+            return noteAt(id, folder, target);
         }),
         deleteFileNotes: async (folderId, paths) => write(database, () => {
             const folder = Number(folderRow(folderId).id);
-            const mark = database.prepare("UPDATE documents SET deleted_at = ?, body = '' WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL");
-            return paths.reduce((sum, path) => sum + mark.run(now(), folder, path).changes, 0);
+            let deleted = 0;
+            for (const path of paths) {
+                const at = now();
+                const place = fileAt(folder, path, true);
+                if (!place) {
+                    const marked = database
+                        .prepare("UPDATE documents SET deleted_at = ?, body = '' WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL RETURNING id")
+                        .all(at, folder, path);
+                    for (const row of marked)
+                        syncFile(database, at, Number(row.id), { seen: false });
+                    deleted += marked.length;
+                    continue;
+                }
+                database.prepare("UPDATE files SET deleted_at = ?, updated_at = ? WHERE id = ?").run(at, at, Number(place.id));
+                deleted++;
+                if (place.document_id == null)
+                    continue;
+                const id = Number(place.document_id);
+                // A document stays while any copy of it is live (requirements 3.1.7).
+                const elsewhere = database
+                    .prepare("SELECT 1 FROM files WHERE document_id = ? AND deleted_at IS NULL AND kind <> 'folder' LIMIT 1")
+                    .get(id);
+                if (elsewhere)
+                    followPreferred(id, at);
+                else
+                    database
+                        .prepare("UPDATE documents SET deleted_at = ?, body = '' WHERE id = ? AND deleted_at IS NULL")
+                        .run(at, id);
+            }
+            return deleted;
         }),
         addNote: async ({ text, title, about = [] }) => write(database, () => {
             const at = now();
@@ -341,7 +531,15 @@ export const notesStoreOver = (context) => {
             const files = options.source === "internal"
                 ? []
                 : database
-                    .prepare("SELECT d.* FROM documents d WHERE d.deleted_at IS NULL AND coalesce(json_extract(d.metadata, '$.catalog.active'), 1)=1 AND (? IS NULL OR d.account_id = ?) " +
+                    .prepare(
+                // In a folder, a document is wherever one of its live files is, under that file's path.
+                (folder === null
+                    ? "SELECT d.* FROM documents d WHERE d.deleted_at IS NULL AND ? IS NULL AND ? IS NULL "
+                    : "SELECT d.*, f.account_id AS account_id, CASE WHEN a.provider IN ('local', 'obsidian') " +
+                        "THEN f.external_id ELSE d.external_id END AS external_id FROM files f " +
+                        "JOIN documents d ON d.id = f.document_id JOIN accounts a ON a.id = f.account_id " +
+                        "WHERE f.deleted_at IS NULL AND d.deleted_at IS NULL AND f.account_id = ? AND ? IS NOT NULL ") +
+                    "AND coalesce(json_extract(d.metadata, '$.catalog.active'), 1)=1 " +
                     `AND (? IS NULL OR EXISTS (SELECT 1 FROM links l WHERE l.from_type = 'document' AND l.from_id = d.id AND l.kind = ${linkKind("about")} AND l.to_type = ? AND l.to_id = ?)) ` +
                     "AND (? IS NULL OR instr(lower(coalesce(d.body, '')), lower(?)) > 0) ORDER BY d.created_at DESC, d.id DESC LIMIT ?")
                     .all(folder, folder, aboutType, aboutType, aboutId, search, search, limit + offset + 1)
@@ -465,12 +663,11 @@ export const notesStoreOver = (context) => {
         replaceFileTags: async (documentId, tags) => write(database, () => {
             const id = Number(documentRow(documentId).id);
             const stated = [...new Set(tags.map(normalizeTag))];
+            const selected = [...new Set(stated.map((name) => ensureTag(context, name).id))];
             database
                 .prepare("DELETE FROM taggings WHERE taggable_type = 'document' AND taggable_id = ? AND source = 'file' " +
-                "AND tag_id NOT IN (SELECT t.id FROM tags t JOIN json_each(?) j ON j.value = t.name)")
-                .run(id, JSON.stringify(stated));
-            for (const tag of stated)
-                ensureTag(context, tag);
+                "AND tag_id NOT IN (SELECT t.id FROM resolved_tags t JOIN json_each(?) j ON j.value=t.canonical_id)")
+                .run(id, JSON.stringify(selected));
             addTags(context, { type: "document", id }, stated, "file");
             return documentTags(id);
         }),

package/dist/store/sqlite/open-store.js

@@ -6,7 +6,9 @@ import { storeCapable } from "../open.js";
 import { storePath } from "../path.js";
 import { sharedConfigPath } from "../shared-config.js";
 import { backfillNormalized, pendingNormalization } from "./backfill.js";
+import { fillFiles } from "./files.js";
 import { fillFolded } from "./folded.js";
+import { fillJoinKeys } from "./join-keys.js";
 import { logPruner } from "./log-pruning.js";
 import { openSqlite } from "./open.js";
 import { loadProviders } from "./providers.js";
@@ -48,7 +50,9 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, ver
             const notice = migrate(database, { now, command, ...(version ? { version } : {}) });
             if (notice)
                 warn(notice);
+            fillFiles(database, now);
             fillFolded(database);
+            fillJoinKeys(database);
             const pending = pendingNormalization(database);
             if (pending > 0 && pending <= BACKFILL_ON_OPEN)
                 backfillNormalized(database);

package/dist/store/sqlite/person-links.js

@@ -154,9 +154,14 @@ export const joinByAddress = (context, ref, address, by) => {
     if (!/^[^\s@]+@[^\s@]+$/.test(key) || ref.provider === "email")
         return;
     const found = required(context, ref);
-    if (!identityRow(context, { provider: "email", id: key }))
+    context.database.prepare("UPDATE identities SET email = ? WHERE id = ? AND email IS NOT ?").run(key, found.pk, key);
+    // The mail contact of the address, found by the address column every contact with one carries (store version 32).
+    const mail = context.database
+        .prepare("SELECT external_id FROM identities WHERE provider = 'email' AND email = ? LIMIT 1")
+        .get(key);
+    if (!mail)
         identityOf(context, "email", key, null);
-    const contact = required(context, { provider: "email", id: key });
+    const contact = required(context, { provider: "email", id: mail ? String(mail.external_id) : key });
     if (contact.personPk === found.personPk || separatedByOwner(context, found.pk, contact.pk))
         return;
     mergePerson(context, found.personPk, contact.personPk, { method: "same-email", by });

package/dist/store/sqlite/schema/canonical-tags.d.ts

@@ -0,0 +1,87 @@
+export declare const canonicalTags: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "canonical_tags";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "canonical_tags";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "canonical_tags";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        kind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "canonical_tags";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "canonical_tags";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "canonical_tags";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+}>;

package/dist/store/sqlite/schema/canonical-tags.js

@@ -0,0 +1,8 @@
+import { integer, sqliteTable, text } from "../drizzle/core.js";
+export const canonicalTags = sqliteTable("canonical_tags", {
+    id: integer("id").primaryKey(),
+    name: text("name").notNull().unique(),
+    kind: text("kind").notNull().default("tag"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+});