@hraness/wordcell 0.22.5 → 0.23.0

package/src/authoring-program.ts

@@ -4,12 +4,12 @@ import {
   MAX_NOTE_BYTES, NoteRevisionConflictError, addRelationToParts, assertCompatibleCreate,
   assertExpected, canonicalNoteId, canonicalRelationTarget, checkedExpectedRevision,
   existingDocumentId, frontmatter, isErrno, normalizeRelationPredicate, noteResult, pathFor, relationsFromParts,
-  removeRelationFromParts, renderCreatedNote, renderFrontmatter, renderUpdatedNoteBody, requireRevision, revisionFor,
-  sameQuarantinedSnapshot, sameSnapshot, withRecoveryPath,
+  removeRelationFromParts, renderCreatedNote, renderFrontmatter, renderUpdatedNoteBodyAndFields, requireRevision, revisionFor,
+  sameQuarantinedSnapshot, sameSnapshot, validateFrontmatterFieldUpdates, validateFrontmatterFields, withRecoveryPath,
 } from "./authoring-model.js";
 import type {
   AuthoringDependencies, AuthoringInstallContext, AuthoringOptions, CreateNoteInput,
-  DirectoryIdentity, NoteAuthoringResult, NoteRevision, NoteSnapshot, RecoveryLocation, UpdateNoteBodyOptions, Vault,
+  DirectoryIdentity, FrontmatterFieldUpdates, FrontmatterFields, NoteAuthoringResult, NoteRevision, NoteSnapshot, RecoveryLocation, UpdateNoteBodyOptions, Vault,
 } from "./authoring-model.js";
 import type { NoteLock } from "./note-lock.js";
 import { parseDocumentId } from "./portfolio-identity.js";
@@ -211,12 +211,18 @@ function installNote(
   });
 }
 
+/**
+ * `fields` is internal: extra top-level frontmatter keys owned by an importer.
+ * The public `createNote` never passes it.
+ */
 export function createNoteProgram(
   platform: AuthoringPlatform, root: string, input: CreateNoteInput, options: AuthoringOptions,
+  fields?: FrontmatterFields,
 ): Effect.Effect<NoteAuthoringResult, AuthoringFailure> {
   return Effect.gen(function*() {
     const vault = yield* authoringNative(() => platform.resolveVault(root));
     const id = yield* authoringSync(() => canonicalNoteId(input.id));
+    const extra = yield* authoringSync(() => validateFrontmatterFields(fields));
     const requestedDocumentId = yield* authoringSync(() => input.documentId === undefined ? undefined : parseDocumentId(input.documentId));
     const expected = yield* authoringSync(() => checkedExpectedRevision(options));
     const dependencies = yield* authoringSync(() => platform.dependenciesFor(options.dependencies));
@@ -227,12 +233,12 @@ export function createNoteProgram(
         const existing = yield* authoringNative(() => platform.readOptionalSnapshot(vault, id));
         if (existing !== null) {
           yield* authoringSync(() => assertExpected(existing, expected));
-          const compatible = yield* authoringSync(() => assertCompatibleCreate(existing, input, requestedDocumentId));
+          const compatible = yield* authoringSync(() => assertCompatibleCreate(existing, input, requestedDocumentId, extra));
           return yield* authoringSync(() => noteResult(existing, compatible.relations, false, compatible.documentId));
         }
         if (expected !== undefined) return yield* fail(new NoteRevisionConflictError(`${id}.md`, expected, null));
         const documentId = yield* authoringSync(() => requestedDocumentId ?? parseDocumentId(dependencies.documentId()));
-        const content = yield* authoringSync(() => renderCreatedNote(input, documentId));
+        const content = yield* authoringSync(() => renderCreatedNote(input, documentId, extra));
         const revision = yield* installNote(platform, vault, id, content, null, lock, dependencies);
         return { changed: true, path: `${id}.md`, revision, relations: [], documentId };
       }),
@@ -277,12 +283,18 @@ export function editNoteRelationProgram(
   });
 }
 
+/**
+ * `fields` is internal: top-level frontmatter keys (and `title`) set in the
+ * same atomic write, where `null` deletes a key. The public `updateNoteBody`
+ * never passes it, so the authored frontmatter bytes stay untouched there.
+ */
 export function updateNoteBodyProgram(
   platform: AuthoringPlatform, root: string, idInput: string, body: string,
-  options: UpdateNoteBodyOptions,
+  options: UpdateNoteBodyOptions, fields?: FrontmatterFieldUpdates,
 ): Effect.Effect<NoteAuthoringResult, AuthoringFailure> {
   return Effect.gen(function*() {
     const id = yield* authoringSync(() => canonicalNoteId(idInput));
+    const updates = yield* authoringSync(() => validateFrontmatterFieldUpdates(fields));
     const expected = yield* authoringSync(() => {
       if (typeof options?.expectedRevision !== "string") {
         throw new TypeError("expectedRevision is required for a note body update");
@@ -302,7 +314,7 @@ export function updateNoteBodyProgram(
         if (identity.kind === "invalid") return yield* fail(new TypeError("the note has an invalid document_id"));
         const documentId = identity.kind === "valid" ? identity.documentId : undefined;
         const relations = yield* authoringSync(() => relationsFromParts(parts, source.relativePath));
-        const content = yield* authoringSync(() => renderUpdatedNoteBody(source, parts, body));
+        const content = yield* authoringSync(() => renderUpdatedNoteBodyAndFields(source, parts, body, updates));
         if (content === source.content) return yield* authoringSync(() => noteResult(source, relations, false, documentId));
         const revision = yield* installNote(platform, vault, id, content, source, lock, dependencies);
         return yield* authoringSync(() => noteResult({ relativePath: source.relativePath, revision }, relations, true, documentId));