@openparachute/vault 0.4.0 → 0.4.3

package/core/src/store.ts

@@ -11,6 +11,7 @@ import {
   loadTagHierarchy,
   getTagDescendants,
   TAG_CONFIG_PREFIX,
+  DEFAULT_TAG_NAME,
   type TagHierarchy,
 } from "./tag-hierarchy.js";
 import {
@@ -19,7 +20,6 @@ import {
   type ResolvedSchemas,
   type ValidationStatus,
 } from "./schema-defaults.js";
-import * as noteSchemaOps from "./note-schemas.js";
 
 /**
  * bun:sqlite-backed Store implementation. Internally everything is
@@ -29,12 +29,11 @@ import * as noteSchemaOps from "./note-schemas.js";
 export class BunSqliteStore implements Store {
   public readonly hooks: HookRegistry;
 
-  // Lazy-built caches over the post-v14 `tags` table (hierarchy via
-  // parent_names) and the post-v15 `note_schemas` + `schema_mappings`
-  // tables (validation). Null means "not yet loaded or invalidated"; the
-  // next read rebuilds. We invalidate synchronously inside the writers
-  // that mutate the source tables so reads after writes always see the
-  // post-write state.
+  // Lazy-built caches over the post-v14 `tags` table — hierarchy via
+  // parent_names, schema validation via `fields`. Null means "not yet
+  // loaded or invalidated"; the next read rebuilds. We invalidate
+  // synchronously inside the writers that mutate the source rows so reads
+  // after writes always see the post-write state.
   private _tagHierarchy: TagHierarchy | null = null;
   private _schemaConfig: ResolvedSchemas | null = null;
 
@@ -55,8 +54,8 @@ export class BunSqliteStore implements Store {
   }
 
   /**
-   * Lazy accessor for the `note_schemas` + `schema_mappings` resolution.
-   * Same lifecycle as the tag hierarchy cache.
+   * Lazy accessor for the per-tag `fields` resolution. Same lifecycle as
+   * the tag hierarchy cache.
    */
   private getSchemaConfig(): ResolvedSchemas {
     if (!this._schemaConfig) this._schemaConfig = loadSchemaConfig(this.db);
@@ -79,9 +78,9 @@ export class BunSqliteStore implements Store {
    * alongside new for rename cases (a note moved out of `_tags/` should
    * still invalidate).
    *
-   * Post-v15 the schema-config cache is no longer note-driven — its
-   * invalidation hook is on `upsertNoteSchema` / `setSchemaMapping` /
-   * `deleteNoteSchema` / `deleteSchemaMapping` instead.
+   * Post-v17 the schema-config cache is purely tag-driven — its
+   * invalidation hook is on `upsertTagSchema` / `upsertTagRecord` /
+   * `deleteTagSchema` / `deleteTag` (mutations of `tags.fields`).
    */
   private invalidateConfigCachesForPath(path: string | null | undefined, oldPath?: string | null): void {
     const isTagConfig = (p: string | null | undefined): boolean =>
@@ -219,16 +218,45 @@ export class BunSqliteStore implements Store {
    * each input tag is replaced with `{tag} ∪ descendants(tag)`. The SQL
    * builder uses this to widen the tag join from `name = ?` to
    * `name IN (...)`, so a query for `#manual` matches notes tagged with
-   * any descendant declared via `_tags/*` config notes.
+   * any descendant declared via `tags.parent_names`.
    *
-   * No-op when no `_tags/*` notes exist (empty hierarchy → each tag
-   * expands to just itself, identical to the pre-expansion behavior).
+   * `_default` magic (vault#270): when a `_default` tag row exists in the
+   * vault, it's the implicit parent of every note (tagged or not). A query
+   * filter that names `_default` is therefore equivalent to "no tag filter
+   * at all" — but the precise treatment depends on `tagMatch`:
+   *
+   * - `all` (default, AND-semantics): `_default` is universally satisfied,
+   *   so it can be dropped from the tag list. Other tags' AND-semantics
+   *   still apply. If `_default` was the only entry, drop the filter
+   *   entirely so untagged notes match.
+   * - `any` (OR-semantics): `_default` matches every note, so the disjunction
+   *   collapses to "every note." Drop the filter entirely regardless of
+   *   what else was in the list (otherwise we'd narrow to the union of
+   *   the other tags' notes — wrong).
+   *
+   * Other filters (path, metadata, dates) still apply in both cases.
    */
   private expandQueryTags(opts: QueryOpts): QueryOpts {
     if (!opts.tags || opts.tags.length === 0) return opts;
     const hierarchy = this.getTagHierarchy();
+
+    let tags = opts.tags;
+    if (hierarchy.allTags.has(DEFAULT_TAG_NAME) && tags.includes(DEFAULT_TAG_NAME)) {
+      const match = opts.tagMatch ?? "all";
+      if (match === "any") {
+        const { tags: _drop, ..._rest } = opts;
+        return _rest as QueryOpts;
+      }
+      tags = tags.filter((t) => t !== DEFAULT_TAG_NAME);
+      if (tags.length === 0) {
+        const { tags: _drop, ..._rest } = opts;
+        return _rest as QueryOpts;
+      }
+      opts = { ...opts, tags };
+    }
+
     if (hierarchy.childrenOf.size === 0) return opts;
-    const expanded = opts.tags.map((t) => Array.from(getTagDescendants(hierarchy, t)));
+    const expanded = tags.map((t) => Array.from(getTagDescendants(hierarchy, t)));
     return { ...opts, _tagsExpanded: expanded } as QueryOpts;
   }
 
@@ -237,9 +265,16 @@ export class BunSqliteStore implements Store {
     // should match notes tagged with any descendant tag. The underlying
     // FTS path already uses `IN (...)` for tags, so we flatten the
     // per-input expansions into a single union (search semantics are
-    // "any tag matches").
+    // "any tag matches"). When `_default` is among the requested tags
+    // (and a `_default` row exists), the OR collapses to "every note" —
+    // drop the tag filter entirely so the search hits the full corpus
+    // and untagged notes are reachable.
     if (opts?.tags && opts.tags.length > 0) {
       const hierarchy = this.getTagHierarchy();
+      if (hierarchy.allTags.has(DEFAULT_TAG_NAME) && opts.tags.includes(DEFAULT_TAG_NAME)) {
+        const { tags: _drop, ..._rest } = opts;
+        return noteOps.searchNotes(this.db, query, _rest);
+      }
       if (hierarchy.childrenOf.size > 0) {
         const expanded = new Set<string>();
         for (const t of opts.tags) {
@@ -277,17 +312,22 @@ export class BunSqliteStore implements Store {
 
   async deleteTag(name: string): Promise<{ deleted: boolean; notes_untagged: number }> {
     const result = noteOps.deleteTag(this.db, name);
-    // The deleted tag may have been a parent or child in the hierarchy.
+    // The deleted tag may have been a parent or child in the hierarchy
+    // and may have declared `fields` powering schema validation.
     this._tagHierarchy = null;
+    this._schemaConfig = null;
     return result;
   }
 
   async renameTag(oldName: string, newName: string): Promise<noteOps.RenameTagResult> {
     const result = noteOps.renameTag(this.db, oldName, newName);
-    // Other tags' parent_names may reference oldName — though we don't
-    // rewrite those, the hierarchy cache should be rebuilt to pick up the
-    // new row identity.
+    // Vault#240: the cascade rewrites parent_names in OTHER tag rows as
+    // part of the same transaction, plus tokens.scoped_tags and
+    // indexed_fields.declarer_tags. Both caches are tag-keyed, so they
+    // must be rebuilt regardless — the hierarchy by tag-set identity,
+    // the schema-config by parent_names + fields content.
     this._tagHierarchy = null;
+    this._schemaConfig = null;
     return result;
   }
 
@@ -297,8 +337,10 @@ export class BunSqliteStore implements Store {
   ): Promise<{ merged: Record<string, number>; target: string }> {
     const result = noteOps.mergeTags(this.db, sources, target);
     // Source tags drop out of the hierarchy; downstream callers asking
-    // for descendants of target should pick up any merged children.
+    // for descendants of target should pick up any merged children. Also
+    // bust the schema cache — `fields` declarations follow tag identity.
     this._tagHierarchy = null;
+    this._schemaConfig = null;
     return result;
   }
 
@@ -332,9 +374,9 @@ export class BunSqliteStore implements Store {
     const notes = noteOps.createNotes(this.db, inputs);
     for (const note of notes) {
       // Bulk path needs the same config-cache invalidation as singleton
-      // createNote — without it, a batch that includes `_tags/*` or
-      // `_schemas/*` notes would leave the cache stale until the next
-      // singleton write happened to bust it.
+      // createNote — without it, a batch that includes `_tags/*` notes
+      // would leave the hierarchy cache stale until the next singleton
+      // write happened to bust it.
       this.invalidateConfigCachesForPath(note.path);
       this.hooks.dispatch("created", note, this);
     }
@@ -370,11 +412,17 @@ export class BunSqliteStore implements Store {
   }
 
   async upsertTagSchema(tag: string, schema: { description?: string; fields?: Record<string, tagSchemaOps.TagFieldSchema> }) {
-    return tagSchemaOps.upsertTagSchema(this.db, tag, schema);
+    const result = tagSchemaOps.upsertTagSchema(this.db, tag, schema);
+    // `fields` drives validation — bust the schema cache so the next
+    // create/update sees the new declarations.
+    this._schemaConfig = null;
+    return result;
   }
 
   async deleteTagSchema(tag: string) {
-    return tagSchemaOps.deleteTagSchema(this.db, tag);
+    const result = tagSchemaOps.deleteTagSchema(this.db, tag);
+    if (result) this._schemaConfig = null;
+    return result;
   }
 
   async getTagSchemaMap() {
@@ -407,7 +455,20 @@ export class BunSqliteStore implements Store {
   ) {
     const result = tagSchemaOps.upsertTagRecord(this.db, tag, patch);
     if (patch.parent_names !== undefined) {
+      // parent_names drives both query expansion (tag hierarchy) AND, post
+      // vault#270, schema inheritance — bust both caches.
+      this._tagHierarchy = null;
+      this._schemaConfig = null;
+    }
+    if (patch.fields !== undefined) {
+      this._schemaConfig = null;
+    }
+    // First-time creation of a tag row (e.g. an empty `_default` placeholder)
+    // changes the `_default` universal-parent gate even when no fields or
+    // parent_names are touched. Cheap to bust: caches rebuild on next read.
+    if (tag === "_default") {
       this._tagHierarchy = null;
+      this._schemaConfig = null;
     }
     return result;
   }
@@ -431,63 +492,14 @@ export class BunSqliteStore implements Store {
   /**
    * Drop the config caches unconditionally. Used by bulk-import paths that
    * skip per-note invalidation for throughput, and by importers that
-   * directly populate `note_schemas` / `schema_mappings`.
+   * directly mutate `tags` / `tags.fields` outside the singleton write
+   * methods.
    */
   rebuildConfigCaches(): void {
     this._tagHierarchy = null;
     this._schemaConfig = null;
   }
 
-  // ---- Note schemas (post-v15: validation by path-prefix or tag) ----
-
-  async listNoteSchemas() {
-    return noteSchemaOps.listNoteSchemas(this.db);
-  }
-
-  async getNoteSchema(name: string) {
-    return noteSchemaOps.getNoteSchema(this.db, name);
-  }
-
-  /**
-   * Partial-upsert a note schema. Auto-creates the row if missing. Any
-   * patch field left undefined is preserved; pass null to clear. Empty
-   * `required: []` collapses to null. Invalidates the schema-config cache.
-   */
-  async upsertNoteSchema(name: string, patch: noteSchemaOps.NoteSchemaPatch) {
-    const result = noteSchemaOps.upsertNoteSchema(this.db, name, patch);
-    this._schemaConfig = null;
-    return result;
-  }
-
-  async deleteNoteSchema(name: string) {
-    const removed = noteSchemaOps.deleteNoteSchema(this.db, name);
-    if (removed) this._schemaConfig = null;
-    return removed;
-  }
-
-  async listSchemaMappings(opts?: noteSchemaOps.ListMappingsOpts) {
-    return noteSchemaOps.listSchemaMappings(this.db, opts ?? {});
-  }
-
-  async setSchemaMapping(
-    schema_name: string,
-    match_kind: noteSchemaOps.SchemaMappingKind,
-    match_value: string,
-  ) {
-    noteSchemaOps.setSchemaMapping(this.db, schema_name, match_kind, match_value);
-    this._schemaConfig = null;
-  }
-
-  async deleteSchemaMapping(
-    schema_name: string,
-    match_kind: noteSchemaOps.SchemaMappingKind,
-    match_value: string,
-  ) {
-    const removed = noteSchemaOps.deleteSchemaMapping(this.db, schema_name, match_kind, match_value);
-    if (removed) this._schemaConfig = null;
-    return removed;
-  }
-
   /**
    * Sync wikilinks for all notes in the vault.
    * Efficient for bulk imports — call once after importing all notes.

package/core/src/tag-hierarchy.ts

@@ -32,8 +32,23 @@ export interface TagHierarchy {
   childrenOf: Map<string, Set<string>>;
   /** Memoization cache: tag → set including the tag itself plus all transitive descendants. */
   descendantsCache: Map<string, Set<string>>;
+  /**
+   * Every known tag name in the vault. Loaded once at hierarchy build so the
+   * `_default` universal-parent magic in `getTagDescendants` can answer
+   * "expand `_default` → every tag" without a second DB scan.
+   */
+  allTags: Set<string>;
 }
 
+/**
+ * Reserved tag name treated as the implicit universal parent of every other
+ * tag (vault#270). When a row named `_default` exists in the `tags` table,
+ * its schema applies to all notes — tagged or not — and tag-hierarchy queries
+ * for `_default` expand to the full tag list. The `tags.parent_names` column
+ * is never auto-mutated; the universal-parent property lives at resolve time.
+ */
+export const DEFAULT_TAG_NAME = "_default";
+
 /**
  * Pre-v14 path prefix that marked a note as a tag-hierarchy declaration.
  * Retained as an exported constant so call-sites that still need to know
@@ -59,16 +74,21 @@ function readParentNames(raw: string | null): string[] {
 /**
  * Scan the `tags` table and build the parent→children adjacency map.
  * Each row's `parent_names` JSON array contributes one edge per parent.
+ * Also collects every known tag name in `allTags` so the `_default`
+ * universal-parent leg in `getTagDescendants` can return the full tag list
+ * without a second scan.
  */
 export function loadTagHierarchy(db: Database): TagHierarchy {
   const rows = db.prepare(
-    `SELECT name, parent_names FROM tags WHERE parent_names IS NOT NULL`,
+    `SELECT name, parent_names FROM tags`,
   ).all() as { name: string; parent_names: string | null }[];
 
   const childrenOf = new Map<string, Set<string>>();
+  const allTags = new Set<string>();
 
   for (const row of rows) {
     if (!row.name) continue;
+    allTags.add(row.name);
     const parents = readParentNames(row.parent_names);
     for (const parent of parents) {
       let children = childrenOf.get(parent);
@@ -80,18 +100,32 @@ export function loadTagHierarchy(db: Database): TagHierarchy {
     }
   }
 
-  return { childrenOf, descendantsCache: new Map() };
+  return { childrenOf, descendantsCache: new Map(), allTags };
 }
 
 /**
  * Return the tag plus all transitive descendants. Always includes the tag
  * itself, so callers can use the result as a drop-in replacement for the
  * input tag when expanding queries.
+ *
+ * Special case: `_default` is treated as the implicit parent of every tag
+ * (vault#270). When a row named `_default` exists in the `tags` table, this
+ * function returns the full set of known tag names — symmetric with the
+ * schema-inheritance model where `_default`'s fields apply to every note.
+ * When `_default` is *not* declared as a tag row, the call falls through to
+ * normal descendant traversal (which yields just `{_default}` since nothing
+ * lists it as a parent).
  */
 export function getTagDescendants(h: TagHierarchy, tag: string): Set<string> {
   const cached = h.descendantsCache.get(tag);
   if (cached) return cached;
 
+  if (tag === DEFAULT_TAG_NAME && h.allTags.has(DEFAULT_TAG_NAME)) {
+    const universal = new Set<string>(h.allTags);
+    h.descendantsCache.set(tag, universal);
+    return universal;
+  }
+
   const result = new Set<string>([tag]);
   const stack = [tag];
   while (stack.length > 0) {

package/core/src/types.ts

@@ -1,23 +1,8 @@
 import type { TagFieldSchema, TagRelationship, TagRecord } from "./tag-schemas.js";
-import type {
-  NoteSchemaField,
-  NoteSchemaRecord,
-  NoteSchemaPatch,
-  SchemaMappingKind,
-  SchemaMappingRecord,
-  ListMappingsOpts,
-} from "./note-schemas.js";
 
 // ---- Re-exports ----
 
 export type { TagFieldSchema, TagRelationship, TagRecord } from "./tag-schemas.js";
-export type {
-  NoteSchemaField,
-  NoteSchemaRecord,
-  NoteSchemaPatch,
-  SchemaMappingKind,
-  SchemaMappingRecord,
-} from "./note-schemas.js";
 
 // ---- Note ----
 
@@ -95,12 +80,14 @@ export interface QueryOpts {
   // as the common path; specifying both this and `dateFilter` rejects.
   dateFrom?: string;    // ISO date
   dateTo?: string;      // ISO date
-  // Generalized date range. `field` defaults to `created_at`; any other
-  // field must be declared `indexed: true` in a tag schema (so the SQL
-  // hits a real B-tree index, same contract as `metadata` operator
-  // queries and `orderBy`). Use this to filter on a *content* date — an
-  // email's received date, a meeting's scheduled date — rather than the
-  // ingestion timestamp.
+  // Generalized date range. `field` defaults to `created_at`; `updated_at`
+  // is also a recognized real column (the incremental-rebuild path —
+  // vault#285 1.5). Any other field must be declared `indexed: true` in a
+  // tag schema (so the SQL hits a real B-tree index, same contract as
+  // `metadata` operator queries and `orderBy`). Use this to filter on a
+  // *content* date — an email's received date, a meeting's scheduled
+  // date — rather than the ingestion timestamp, or on `updated_at` to ask
+  // "what changed since X."
   dateFilter?: {
     field?: string;
     from?: string;
@@ -175,7 +162,19 @@ export interface Store {
   renameTag(
     oldName: string,
     newName: string,
-  ): Promise<{ renamed: number } | { error: "not_found" } | { error: "target_exists" }>;
+  ): Promise<
+    | {
+        renamed: number;
+        sub_tags_renamed: number;
+        parent_refs_updated: number;
+        tokens_updated: number;
+        indexed_field_declarers_updated: number;
+        notes_rewritten: number;
+        paths_renamed: number;
+      }
+    | { error: "not_found" }
+    | { error: "target_exists"; conflicting: string[] }
+  >;
   mergeTags(
     sources: string[],
     target: string,
@@ -228,30 +227,26 @@ export interface Store {
     },
   ): Promise<TagRecord>;
 
-  // Schema validation (post-v15: backed by `note_schemas` + `schema_mappings`
-  // tables). Returns null when no schema applies to the given note. The
-  // underlying resolver is in-memory after the first lazy load.
+  // Schema validation (post-v17: backed by `tags.fields` only — the
+  // standalone note_schemas + schema_mappings subsystem retired in v17, see
+  // vault#267). Post vault#270 the resolver walks `parent_names` so a note's
+  // effective fields include all ancestors' declarations (first-in-walk wins
+  // on conflict, surfaced as `schema_conflict` warnings); a tag named
+  // `_default` is the implicit universal parent. Returns null when no
+  // ancestor declares any fields. The underlying resolver is in-memory after
+  // the first lazy load.
   validateNoteAgainstSchemas(note: { path?: string | null; tags?: string[]; metadata?: Record<string, unknown> }): {
     schemas: string[];
-    warnings: { field: string; schema: string; reason: "missing_required" | "type_mismatch" | "enum_mismatch"; message: string }[];
+    warnings: {
+      field: string;
+      schema: string;
+      reason: "type_mismatch" | "enum_mismatch" | "schema_conflict";
+      message: string;
+      /** Set only on `schema_conflict` — the tag whose declaration was overridden. */
+      loser_schema?: string;
+    }[];
   } | null;
 
-  // Note schemas (post-v15 — the writable surface that drives validation).
-  listNoteSchemas(): Promise<NoteSchemaRecord[]>;
-  getNoteSchema(name: string): Promise<NoteSchemaRecord | null>;
-  /**
-   * Partial-upsert. Auto-creates the row if missing. Any patch field left
-   * undefined is preserved; pass null to clear. Empty `required: []`
-   * collapses to null.
-   */
-  upsertNoteSchema(name: string, patch: NoteSchemaPatch): Promise<NoteSchemaRecord>;
-  deleteNoteSchema(name: string): Promise<boolean>;
-
-  // Schema mappings (post-v15 — replaces the singleton `_schema_defaults`).
-  listSchemaMappings(opts?: ListMappingsOpts): Promise<SchemaMappingRecord[]>;
-  setSchemaMapping(schema_name: string, match_kind: SchemaMappingKind, match_value: string): Promise<void>;
-  deleteSchemaMapping(schema_name: string, match_kind: SchemaMappingKind, match_value: string): Promise<boolean>;
-
   // Attachments
   addAttachment(noteId: string, path: string, mimeType: string, metadata?: Record<string, unknown>): Promise<Attachment>;
   getAttachments(noteId: string): Promise<Attachment[]>;