@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/commands/notes/actions.js

@@ -15,6 +15,8 @@ import { parseNoteSearchFields, projectNoteSearchFields } from './searchOutput.j
 import { parseCreatedAtRange } from './searchTime.js';
 import { buildNoteSearchResponse, normalizeDaysForMeta } from './searchResponse.js';
 import { parseMutationListInput, parseNoteType, parsePreviewLineCount, parseSearchLimit, parseSearchListInput, parseSearchOffset, parseStarredOption, parseStringInput, parseStringListInput, parseTargetNoteIds, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+import { readNoteProperties } from '../properties/repo.js';
+import { createNoteWithSeed, previewNoteCreateProperties, resolveNoteCreateSeed } from './createFromTemplate.js';
 function toPublicNoteContext(note) {
     if (!note) {
         return null;
@@ -368,14 +370,31 @@ export async function runNoteDetail({ command, options, args }) {
 export async function runNoteCreate({ command, options }) {
     const createOptions = options;
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    if (createOptions.content === undefined && !createOptions.template) {
+        throw new DinoxError('--content is required unless --template is given', { code: 'USAGE_ERROR' });
+    }
     await withNoteDatabase(command, async (runtime) => {
         const { db, config, offline } = runtime;
         await syncBeforeNoteCommand(runtime);
         const durability = resolveWriteDurabilityForRuntime(runtime, createOptions.durability);
         const identity = await resolveAuthIdentity(config);
-        const contentMd = await parseStringInput(String(createOptions.content));
-        const canonicalContentMd = await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
-        const { contentJson, contentText } = convertMarkdownToNoteContent(canonicalContentMd);
+        const seed = await resolveNoteCreateSeed(db, {
+            userId: identity.userId,
+            templateId: createOptions.template,
+            properties: createOptions.properties,
+        });
+        // Template content is used as the hydrated Tiptap document itself (as desktop does), so
+        // only explicit --content goes through Markdown conversion.
+        const useTemplateContent = createOptions.content === undefined && seed.templateContent !== null;
+        const contentMd = useTemplateContent
+            ? seed.templateContent.contentMd
+            : createOptions.content !== undefined ? await parseStringInput(String(createOptions.content)) : '';
+        const canonicalContentMd = useTemplateContent
+            ? contentMd
+            : await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
+        const { contentJson, contentText } = useTemplateContent
+            ? { contentJson: seed.templateContent.contentJson, contentText: seed.templateContent.contentText }
+            : convertMarkdownToNoteContent(canonicalContentMd);
         const tagsInput = typeof createOptions.tags === 'string'
             ? await parseStringListInput(createOptions.tags, '--tags')
             : [];
@@ -383,8 +402,21 @@ export async function runNoteCreate({ command, options }) {
             ? await parseStringListInput(createOptions.boxes, '--boxes')
             : [];
         const noteType = parseNoteType(createOptions.type);
+        const id = generateId();
+        const insert = async (tx) => createNote(tx, {
+            id,
+            title: String(createOptions.title),
+            noteType,
+            contentMd: canonicalContentMd,
+            contentJson,
+            contentText,
+            tags: await validateTagsForCreate(tx, tagsInput, identity.userId),
+            zettelBoxIds: await resolveZettelBoxIdsForCreate(tx, boxNames),
+            userId: identity.userId,
+            properties: seed.propertiesJson,
+        });
         if (Boolean(createOptions.dryRun)) {
-            printDryRunPreview(await buildNoteCreateDryRunPreview({
+            const preview = await buildNoteCreateDryRunPreview({
                 db,
                 config,
                 offline,
@@ -394,27 +426,24 @@ export async function runNoteCreate({ command, options }) {
                 contentMd,
                 tagsInput,
                 zettelBoxNames: boxNames,
-            }), runtime);
+            });
+            if (seed.template || seed.values) {
+                const properties = await previewNoteCreateProperties(db, { noteId: id, userId: identity.userId, seed, insert });
+                preview.inputs = { ...preview.inputs, ...(seed.template ? { template: { id: seed.template.id, name: seed.template.name } } : {}) };
+                preview.changes = { ...preview.changes, properties: properties.properties };
+            }
+            printDryRunPreview(preview, runtime);
             return;
         }
-        const id = generateId();
-        await createNote(db, {
-            id,
-            title: String(createOptions.title),
-            noteType,
-            contentMd: canonicalContentMd,
-            contentJson,
-            contentText,
-            tags: await validateTagsForCreate(db, tagsInput, identity.userId),
-            zettelBoxIds: await resolveZettelBoxIdsForCreate(db, boxNames),
-            userId: identity.userId,
-        });
+        await createNoteWithSeed(db, { noteId: id, userId: identity.userId, seed, insert });
         const upload = await waitForMutationUpload(runtime, { durability });
         const payload = {
             ok: true,
             id,
+            ...(seed.template ? { template: { id: seed.template.id, name: seed.template.name } } : {}),
+            ...(seed.template || seed.values ? { properties: (await readNoteProperties(db, { userId: identity.userId, noteId: id })).properties } : {}),
             ...(await readNoteWriteReceipt(db, id, {
-                changed: ['title', 'type', 'content_md', 'content_json', 'content_text', 'tags', 'boxes'],
+                changed: ['title', 'type', 'content_md', 'content_json', 'content_text', 'tags', 'boxes', ...(seed.template || seed.values ? ['properties'] : [])],
                 upload,
                 stale: commandStale(runtime),
             })),

package/dist/commands/notes/createFromTemplate.d.ts

@@ -0,0 +1,35 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type NotePropertiesPatch } from '../../vendor/electron/shared/index.js';
+import { type NotePropertiesView } from '../properties/repo.js';
+import { type NoteTemplateDetail } from '../templates/model.js';
+export type NoteCreateSeed = {
+    template: NoteTemplateDetail | null;
+    /** Hydrated template content projected like stored note content; null without content. */
+    templateContent: {
+        contentJson: unknown;
+        contentMd: string;
+        contentText: string;
+    } | null;
+    /** Serialized `c_note.properties` holding the template's declared empty slots. */
+    propertiesJson: string | null;
+    values: NotePropertiesPatch | null;
+};
+export declare function resolveNoteCreateSeed(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    templateId?: string;
+    properties?: unknown;
+}): Promise<NoteCreateSeed>;
+/** Inserts the note and its initial property values atomically. */
+export declare function createNoteWithSeed(db: AbstractPowerSyncDatabase, input: {
+    noteId: string;
+    userId: string;
+    seed: NoteCreateSeed;
+    insert: (tx: AbstractPowerSyncDatabase) => Promise<unknown>;
+}): Promise<void>;
+/** Dry-run: performs the insert and property writes, reads the resulting properties, rolls back. */
+export declare function previewNoteCreateProperties(db: AbstractPowerSyncDatabase, input: {
+    noteId: string;
+    userId: string;
+    seed: NoteCreateSeed;
+    insert: (tx: AbstractPowerSyncDatabase) => Promise<unknown>;
+}): Promise<NotePropertiesView>;

package/dist/commands/notes/createFromTemplate.js

@@ -0,0 +1,58 @@
+// `note create --template/--properties`: seeds a new note the way desktop's "create from
+// template" does — hydrated template content plus the template's property keys declared as
+// empty slots — and optionally writes initial property values in the same transaction.
+import { DinoxError } from '../../utils/errors.js';
+import { applyNotePropertySlotOperation, serializeRawNoteProperties, } from '../../vendor/electron/shared/index.js';
+import { previewInRolledBackTransaction, runDomainCommand, withNestedWriteTransaction } from '../domain/run.js';
+import { readJsonOption } from '../domain/options.js';
+import { readNoteProperties } from '../properties/repo.js';
+import { hydrateNoteTemplateDocument } from '../templates/model.js';
+import { getNoteTemplate } from '../templates/repo.js';
+import { projectNoteContent } from './contentEngine.js';
+export async function resolveNoteCreateSeed(db, input) {
+    const template = input.templateId ? await getNoteTemplate(db, { userId: input.userId, id: input.templateId }) : null;
+    const projection = template?.document ? projectNoteContent(hydrateNoteTemplateDocument(template.document)) : null;
+    const templateContent = projection
+        ? { contentJson: projection.document, contentMd: projection.contentMd, contentText: projection.contentText }
+        : null;
+    const declared = applyNotePropertySlotOperation({}, 'declare', template?.propertyKeys ?? []).next;
+    let values = null;
+    if (input.properties !== undefined) {
+        const raw = await readJsonOption(input.properties, '--properties', 'note.create');
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+            throw new DinoxError('--properties must be a JSON object of property key to value', { code: 'USAGE_ERROR' });
+        }
+        values = raw;
+        if (Object.keys(values).length === 0)
+            values = null;
+    }
+    return { template, templateContent, propertiesJson: serializeRawNoteProperties(declared), values };
+}
+async function applyValues(tx, noteId, userId, seed) {
+    if (!seed.values)
+        return;
+    await runDomainCommand(tx, 'notes.updateProperties', {
+        noteId,
+        userId,
+        patch: seed.values,
+        updatedAt: new Date().toISOString(),
+    });
+}
+/** Inserts the note and its initial property values atomically. */
+export async function createNoteWithSeed(db, input) {
+    if (!input.seed.values) {
+        await input.insert(db);
+        return;
+    }
+    await withNestedWriteTransaction(db, async (tx) => {
+        await input.insert(tx);
+        await applyValues(tx, input.noteId, input.userId, input.seed);
+    });
+}
+/** Dry-run: performs the insert and property writes, reads the resulting properties, rolls back. */
+export async function previewNoteCreateProperties(db, input) {
+    return previewInRolledBackTransaction(db, async (tx) => {
+        await input.insert(tx);
+        await applyValues(tx, input.noteId, input.userId, input.seed);
+    }, (tx) => readNoteProperties(tx, { userId: input.userId, noteId: input.noteId }));
+}

package/dist/commands/notes/descriptors.js

@@ -176,10 +176,12 @@ export const noteCommandGroup = {
         },
         {
             name: 'create',
-            description: 'Create a new note from markdown content',
+            description: 'Create a new note from markdown content or a note template',
             options: [
                 { flags: '--title <string>', description: 'Note title', required: true, type: 'string' },
-                { flags: '--content <string|@file>', description: 'Markdown content', required: true, type: 'string' },
+                { flags: '--content <string|@file>', description: 'Markdown content (required unless --template is given; overrides template content)', type: 'string' },
+                { flags: '--template <id>', description: 'Note template id: hydrates its content ({{date}}, {{time}}, ...) and declares its property keys as empty slots', type: 'string' },
+                { flags: '--properties <json|@file>', description: 'Initial property values as a JSON object; validated against property definitions', type: 'string' },
                 { flags: '--type <note|crawl>', description: 'Note type: note or crawl', type: 'string', defaultValue: 'crawl', enum: ['note', 'crawl'] },
                 { flags: '--tags <string|@file>', description: 'Tag list (JSON array or comma/newline-separated)', type: 'string' },
                 { flags: '--boxes <string|@file>', description: 'Box paths or unique names (JSON array or comma/newline-separated)', type: 'string' },
@@ -194,9 +196,12 @@ export const noteCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Creation acknowledgement with write durability, queue state, and note revision receipt',
-                    fields: ['id', ...NOTE_WRITE_RECEIPT_FIELDS],
+                    fields: ['id', 'template', 'properties', ...NOTE_WRITE_RECEIPT_FIELDS],
                 },
-                examples: ['dino note create --title "Weekly note" --content @/tmp/note.md --type note --durability uploaded --format json'],
+                examples: [
+                    'dino note create --title "Weekly note" --content @/tmp/note.md --type note --durability uploaded --format json',
+                    'dino note create --title "Dune" --template <templateId> --properties \'{"rating":5}\' --type note --format json --dry-run',
+                ],
             },
             action: runNoteCreate,
         },

package/dist/commands/notes/repo/read.js

@@ -1,6 +1,6 @@
 // Note reads: single-note lookup, context, preview, detail, and export rows.
-import { DinoxError } from '../../../utils/errors.js';
 import { loadZettelBoxNameMap, normalizeStoredFlag, normalizeStoredStarred, parseStoredTags, parseZettelBoxIds, resolveSummary, } from './shared.js';
+import { parseRawNoteProperties } from '../../../vendor/electron/shared/index.js';
 export async function getNote(db, id) {
     return db.getOptional(`
     SELECT
@@ -158,29 +158,10 @@ function parseStoredJsonValue(raw) {
         return raw;
     }
 }
+// Same forgiving read as desktop: malformed storage reads as {} instead of failing the
+// whole note read; `dino prop show` reports it via `valid: false`.
 function parseStoredNoteProperties(raw) {
-    const value = raw?.trim() ?? '';
-    if (!value) {
-        return {};
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(value);
-    }
-    catch (cause) {
-        throw new DinoxError('c_note.properties must be valid JSON', {
-            code: 'NOTE_INVALID_PROPERTIES',
-            details: { cause: cause instanceof Error ? cause.message : String(cause) },
-            recoverable: false,
-        });
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new DinoxError('c_note.properties must be a JSON object', {
-            code: 'NOTE_INVALID_PROPERTIES',
-            recoverable: false,
-        });
-    }
-    return Object.fromEntries(Object.entries(parsed));
+    return parseRawNoteProperties(raw);
 }
 function mapNoteExportRow(note, boxNameMap) {
     const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);

package/dist/commands/notes/repo/write.d.ts

@@ -11,6 +11,8 @@ export declare function createNote(db: AbstractPowerSyncDatabase, input: {
     zettelBoxIds: string[];
     userId: string;
     imageDetail?: unknown[];
+    /** Serialized `c_note.properties` (e.g. template-declared empty slots); defaults to NULL. */
+    properties?: string | null;
 }): Promise<{
     id: string;
 }>;

package/dist/commands/notes/repo/write.js

@@ -77,7 +77,7 @@ export async function createNote(db, input) {
         ['resource_id', null],
         ['note_ids', '[]'],
         ['extra_data', '{}'],
-        ['properties', null],
+        ['properties', input.properties ?? null],
         ['is_pub', 0],
         ['format_type', ''],
         ['comments', '[]'],

package/dist/commands/properties/index.d.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import { PROPERTY_OPTION_COLORS, STATUS_PROPERTY_GROUPS } from '../../vendor/electron/shared/index.js';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+type Color = (typeof PROPERTY_OPTION_COLORS)[number];
+type Group = (typeof STATUS_PROPERTY_GROUPS)[number];
+/** Parses `label[:color[:group]]`, peeling recognised color/group suffixes off the right. */
+export declare function parseOptionSpec(spec: string): {
+    label: string;
+    color?: Color;
+    group?: Group;
+};
+/** Parses `key=value`; the value is JSON when it parses as JSON, otherwise a plain string. */
+export declare function parseAssignment(spec: string): [string, unknown];
+export declare const propertyCommandGroup: CommandGroupDescriptor;
+export declare function registerPropertyCommands(program: Command): void;
+export {};