@dinoxx/dinox-cli 2.2.0 → 2.3.0

package/dist/commands/templates/repo.js

@@ -0,0 +1,78 @@
+import { DinoxError } from '../../utils/errors.js';
+import { fetchDomainReadModel, previewInRolledBackTransaction, runDomainCommand, } from '../domain/run.js';
+import { mapNoteTemplateRow } from './model.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+function notFound(id) {
+    return new DinoxError(`Note template not found: ${id}`, {
+        code: 'NOTE_TEMPLATE_NOT_FOUND',
+        details: { templateId: id },
+        suggestion: 'Run `dino template list --format json` to see template ids.',
+    });
+}
+export async function listNoteTemplates(db, input) {
+    const rows = await fetchDomainReadModel(db, 'noteTemplates.catalog', {
+        userId: input.userId,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+    });
+    return rows.map(mapNoteTemplateRow);
+}
+export async function getNoteTemplate(db, input) {
+    const row = await db.getOptional(`
+      SELECT id, user_id, name, content, priority, is_show, extra_data, property_def,
+        insert_at, update_at, is_del
+      FROM c_note_template
+      WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+      LIMIT 1
+    `, [input.id.trim(), input.userId]);
+    if (!row)
+        throw notFound(input.id);
+    return mapNoteTemplateRow(row);
+}
+async function runCreate(db, input) {
+    const { result: id } = await runDomainCommand(db, 'noteTemplates.create', {
+        userId: input.userId,
+        name: input.name,
+        propertyKeys: input.propertyKeys ?? [],
+        ...(input.content === undefined ? {} : { content: input.content }),
+        updatedAt: nowIso(),
+    });
+    return getNoteTemplate(db, { userId: input.userId, id });
+}
+async function runUpdate(db, input) {
+    await getNoteTemplate(db, input);
+    await runDomainCommand(db, 'noteTemplates.update', {
+        id: input.id,
+        userId: input.userId,
+        ...(input.name === undefined ? {} : { name: input.name }),
+        ...(input.propertyKeys === undefined ? {} : { propertyKeys: input.propertyKeys }),
+        ...(input.content === undefined ? {} : { content: input.content }),
+        updatedAt: nowIso(),
+    });
+    return getNoteTemplate(db, input);
+}
+async function runDelete(db, input) {
+    const before = await getNoteTemplate(db, input);
+    const { result: changed } = await runDomainCommand(db, 'noteTemplates.softDelete', {
+        id: input.id,
+        userId: input.userId,
+        updatedAt: nowIso(),
+    });
+    if (!changed)
+        throw notFound(input.id);
+    return before;
+}
+export const createNoteTemplate = runCreate;
+export const updateNoteTemplate = runUpdate;
+export const deleteNoteTemplate = runDelete;
+export async function previewCreateNoteTemplate(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runCreate(tx, input), async (_tx, after) => ({ before: null, after }));
+}
+export async function previewUpdateNoteTemplate(db, input) {
+    const before = await getNoteTemplate(db, input);
+    return previewInRolledBackTransaction(db, (tx) => runUpdate(tx, input), async (_tx, after) => ({ before, after }));
+}
+export async function previewDeleteNoteTemplate(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runDelete(tx, input), async (_tx, before) => ({ before, after: null }));
+}

package/dist/skills/registry.js

@@ -18,6 +18,13 @@ const REGISTRY_ENTRIES = [
         name: 'dino-manage-boxes',
         generated: [commands('SKILL.md', 'skill:dino-manage-boxes')],
     },
+    {
+        name: 'dino-manage-properties',
+        generated: [
+            commands('SKILL.md', 'skill:dino-manage-properties'),
+            commands('references/templates.md', 'skill:dino-manage-properties:templates'),
+        ],
+    },
     {
         name: 'dino-manage-prompts',
         generated: [commands('SKILL.md', 'skill:dino-manage-prompts')],

package/dist/utils/errorCodes.d.ts

@@ -95,6 +95,18 @@ export declare const ERROR_CODES: {
         readonly exitCode: 2;
         readonly description: "An argument or option value is invalid.";
     };
+    readonly INVALID_PROPERTY_DEF_CONFIG: {
+        readonly exitCode: 1;
+        readonly description: "A property definition config could not be serialized.";
+    };
+    readonly INVALID_PROPERTY_DEF_ID: {
+        readonly exitCode: 1;
+        readonly description: "A property definition id is missing or blank.";
+    };
+    readonly INVALID_PROPERTY_OPTIONS: {
+        readonly exitCode: 1;
+        readonly description: "Property options could not be serialized.";
+    };
     readonly INVALID_STORAGE_KEY: {
         readonly exitCode: 2;
         readonly description: "The storage object key is invalid.";
@@ -107,6 +119,22 @@ export declare const ERROR_CODES: {
         readonly exitCode: 5;
         readonly description: "The note does not exist or is deleted.";
     };
+    readonly NOTE_PROPERTIES_CORRUPT: {
+        readonly exitCode: 1;
+        readonly description: "The note properties JSON is corrupt and cannot be mutated safely.";
+    };
+    readonly NOTE_PROPERTIES_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "The note properties mutation is invalid.";
+    };
+    readonly NOTE_PROPERTIES_MUTATION_FAILED: {
+        readonly exitCode: 1;
+        readonly description: "The note properties mutation could not be applied.";
+    };
+    readonly NOTE_PROPERTY_ORDER_STALE: {
+        readonly exitCode: 5;
+        readonly description: "The property slot order no longer matches the note; re-read and retry.";
+    };
     readonly NOTE_TEMPLATE_INVALID_CONTENT: {
         readonly exitCode: 1;
         readonly description: "The note template content is invalid.";
@@ -119,6 +147,10 @@ export declare const ERROR_CODES: {
         readonly exitCode: 1;
         readonly description: "A note template token is used in an invalid context.";
     };
+    readonly NOTE_TEMPLATE_NOT_FOUND: {
+        readonly exitCode: 5;
+        readonly description: "The note template does not exist or is deleted.";
+    };
     readonly NOTE_TEMPLATE_UNSUPPORTED_PROPERTY_DEF_VERSION: {
         readonly exitCode: 1;
         readonly description: "The note template property definition version is unsupported.";
@@ -135,6 +167,166 @@ export declare const ERROR_CODES: {
         readonly exitCode: 5;
         readonly description: "A safety precondition for the operation did not hold.";
     };
+    readonly PROPERTY_DATE_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A date property value is not a valid date.";
+    };
+    readonly PROPERTY_DEF_CONFIG_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A property definition config is invalid.";
+    };
+    readonly PROPERTY_DEF_CONFIG_TYPE_MISMATCH: {
+        readonly exitCode: 1;
+        readonly description: "A property definition config does not match the property type.";
+    };
+    readonly PROPERTY_DEF_ENSURE_FAILED: {
+        readonly exitCode: 1;
+        readonly description: "The property definition could not be created or reused.";
+    };
+    readonly PROPERTY_DEF_ENSURE_INPUT_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "The property definition create input is invalid.";
+    };
+    readonly PROPERTY_DEF_NOT_FOUND: {
+        readonly exitCode: 5;
+        readonly description: "The property definition does not exist or is deleted.";
+    };
+    readonly PROPERTY_DEF_TYPE_CONFLICT: {
+        readonly exitCode: 5;
+        readonly description: "A property with this key already exists with a different type.";
+    };
+    readonly PROPERTY_DEF_TYPE_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "The stored property definition type is invalid.";
+    };
+    readonly PROPERTY_FILES_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A files property value is invalid.";
+    };
+    readonly PROPERTY_LEGACY_OPTION_LABEL_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A legacy option label cannot be migrated.";
+    };
+    readonly PROPERTY_LEGACY_OPTION_NOT_PLANNED: {
+        readonly exitCode: 1;
+        readonly description: "A legacy option value was not covered by the migration plan.";
+    };
+    readonly PROPERTY_LEGACY_VALUE_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A legacy option value cannot be migrated.";
+    };
+    readonly PROPERTY_MULTI_SELECT_EMPTY: {
+        readonly exitCode: 1;
+        readonly description: "A multi-select property value is empty.";
+    };
+    readonly PROPERTY_MULTI_SELECT_LIMIT_EXCEEDED: {
+        readonly exitCode: 1;
+        readonly description: "A multi-select property value has too many selections.";
+    };
+    readonly PROPERTY_NUMBER_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A number property value is invalid or out of range.";
+    };
+    readonly PROPERTY_OPTIONS_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "Stored property options are invalid.";
+    };
+    readonly PROPERTY_OPTIONS_MIGRATION_REQUIRED: {
+        readonly exitCode: 5;
+        readonly description: "Legacy property options must be migrated first (dino prop migrate-options).";
+    };
+    readonly PROPERTY_OPTIONS_TYPE_MISMATCH: {
+        readonly exitCode: 1;
+        readonly description: "Options were supplied for a property type that has none.";
+    };
+    readonly PROPERTY_OPTION_ARCHIVED: {
+        readonly exitCode: 5;
+        readonly description: "The select option is archived and cannot be assigned.";
+    };
+    readonly PROPERTY_OPTION_ID_DUPLICATE: {
+        readonly exitCode: 1;
+        readonly description: "Property options contain duplicate ids.";
+    };
+    readonly PROPERTY_OPTION_ID_UNKNOWN: {
+        readonly exitCode: 1;
+        readonly description: "A property option id does not exist on the definition.";
+    };
+    readonly PROPERTY_OPTION_LABEL_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A property option label is blank, too long, or duplicated.";
+    };
+    readonly PROPERTY_OPTION_LIMIT_EXCEEDED: {
+        readonly exitCode: 1;
+        readonly description: "The property has too many options.";
+    };
+    readonly PROPERTY_OPTION_NEW_ID_FORBIDDEN: {
+        readonly exitCode: 1;
+        readonly description: "New property options must not carry an id.";
+    };
+    readonly PROPERTY_OPTION_NOT_FOUND: {
+        readonly exitCode: 5;
+        readonly description: "The select option does not exist on a closed property.";
+    };
+    readonly PROPERTY_OPTION_REMOVAL_REQUIRES_ARCHIVE: {
+        readonly exitCode: 1;
+        readonly description: "Existing property options must be archived instead of removed.";
+    };
+    readonly PROPERTY_OPTION_REPAIR_ID_FORBIDDEN: {
+        readonly exitCode: 1;
+        readonly description: "Repair options must not carry ids.";
+    };
+    readonly PROPERTY_OPTION_SORT_RANK_EXHAUSTED: {
+        readonly exitCode: 1;
+        readonly description: "No sort rank is left for a new property option.";
+    };
+    readonly PROPERTY_OPTION_VALUE_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A select property value is invalid.";
+    };
+    readonly PROPERTY_PLACE_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A place property value is invalid.";
+    };
+    readonly PROPERTY_RELATION_EMPTY: {
+        readonly exitCode: 1;
+        readonly description: "A relation property value is empty.";
+    };
+    readonly PROPERTY_RELATION_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A relation property value references invalid notes.";
+    };
+    readonly PROPERTY_RELATION_LIMIT: {
+        readonly exitCode: 1;
+        readonly description: "A relation property value has too many notes.";
+    };
+    readonly PROPERTY_TYPE_NOT_ACTIVE: {
+        readonly exitCode: 1;
+        readonly description: "The property type is not active.";
+    };
+    readonly PROPERTY_UNIQUE_ID_CONFIG_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A unique-id property counter is invalid.";
+    };
+    readonly PROPERTY_UNIQUE_ID_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A unique-id property value is invalid.";
+    };
+    readonly PROPERTY_UNIQUE_ID_TYPE_MISMATCH: {
+        readonly exitCode: 1;
+        readonly description: "A unique-id setting was supplied for a different property type.";
+    };
+    readonly PROPERTY_URL_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A url property value is invalid.";
+    };
+    readonly PROPERTY_VALUE_INVALID: {
+        readonly exitCode: 1;
+        readonly description: "A property value does not match its definition.";
+    };
+    readonly SAVED_VIEW_FILTER_CORRUPT: {
+        readonly exitCode: 1;
+        readonly description: "A stored saved view filter is corrupt.";
+    };
     readonly SAVED_VIEW_FILTER_TOO_COMPLEX: {
         readonly exitCode: 1;
         readonly description: "The saved view filter exceeds supported complexity.";
@@ -147,6 +339,10 @@ export declare const ERROR_CODES: {
         readonly exitCode: 1;
         readonly description: "The saved view config is invalid.";
     };
+    readonly SAVED_VIEW_INVALID_CURRENT_TIME: {
+        readonly exitCode: 1;
+        readonly description: "The reference time for dynamic date filters is invalid.";
+    };
     readonly SAVED_VIEW_INVALID_DATE_VALUE: {
         readonly exitCode: 1;
         readonly description: "A saved view date value is not a real calendar date.";
@@ -159,10 +355,22 @@ export declare const ERROR_CODES: {
         readonly exitCode: 1;
         readonly description: "The saved view filter is invalid.";
     };
+    readonly SAVED_VIEW_INVALID_OPERATOR: {
+        readonly exitCode: 1;
+        readonly description: "A saved view filter operator is invalid.";
+    };
+    readonly SAVED_VIEW_INVALID_RELATIVE_DAYS: {
+        readonly exitCode: 1;
+        readonly description: "withinLastDays requires an integer day count in range.";
+    };
     readonly SAVED_VIEW_INVALID_ROW: {
         readonly exitCode: 1;
         readonly description: "A stored saved view row is invalid.";
     };
+    readonly SAVED_VIEW_INVALID_TIME_ZONE: {
+        readonly exitCode: 2;
+        readonly description: "The time zone is not a valid IANA time zone.";
+    };
     readonly SAVED_VIEW_NOT_FOUND: {
         readonly exitCode: 5;
         readonly description: "The saved view does not exist.";
@@ -199,6 +407,10 @@ export declare const ERROR_CODES: {
         readonly exitCode: 1;
         readonly description: "The field type cannot be sorted.";
     };
+    readonly SAVED_VIEW_TIME_ZONE_CONVERSION_FAILED: {
+        readonly exitCode: 1;
+        readonly description: "A dynamic date boundary could not be converted to the time zone.";
+    };
     readonly SAVED_VIEW_UNSUPPORTED_CONFIG_VERSION: {
         readonly exitCode: 1;
         readonly description: "The saved view config version is unsupported.";

package/dist/utils/errorCodes.js

@@ -29,23 +29,75 @@ export const ERROR_CODES = {
     DAEMON_UNREACHABLE: { exitCode: 1, description: 'The daemon socket could not be reached.' },
     INTERNAL_ERROR: { exitCode: 1, description: 'Unexpected internal error; not a DinoxError.' },
     INVALID_ARGUMENT: { exitCode: 2, description: 'An argument or option value is invalid.' },
+    INVALID_PROPERTY_DEF_CONFIG: { exitCode: 1, description: 'A property definition config could not be serialized.' },
+    INVALID_PROPERTY_DEF_ID: { exitCode: 1, description: 'A property definition id is missing or blank.' },
+    INVALID_PROPERTY_OPTIONS: { exitCode: 1, description: 'Property options could not be serialized.' },
     INVALID_STORAGE_KEY: { exitCode: 2, description: 'The storage object key is invalid.' },
     NOTE_INVALID_PROPERTIES: { exitCode: 1, description: 'Note properties are invalid.' },
     NOTE_NOT_FOUND: { exitCode: 5, description: 'The note does not exist or is deleted.' },
+    NOTE_PROPERTIES_CORRUPT: { exitCode: 1, description: 'The note properties JSON is corrupt and cannot be mutated safely.' },
+    NOTE_PROPERTIES_INVALID: { exitCode: 1, description: 'The note properties mutation is invalid.' },
+    NOTE_PROPERTIES_MUTATION_FAILED: { exitCode: 1, description: 'The note properties mutation could not be applied.' },
+    NOTE_PROPERTY_ORDER_STALE: { exitCode: 5, description: 'The property slot order no longer matches the note; re-read and retry.' },
     NOTE_TEMPLATE_INVALID_CONTENT: { exitCode: 1, description: 'The note template content is invalid.' },
     NOTE_TEMPLATE_INVALID_PROPERTY_DEF: { exitCode: 1, description: 'A note template property definition is invalid.' },
     NOTE_TEMPLATE_INVALID_TOKEN_CONTEXT: { exitCode: 1, description: 'A note template token is used in an invalid context.' },
+    NOTE_TEMPLATE_NOT_FOUND: { exitCode: 5, description: 'The note template does not exist or is deleted.' },
     NOTE_TEMPLATE_UNSUPPORTED_PROPERTY_DEF_VERSION: { exitCode: 1, description: 'The note template property definition version is unsupported.' },
     NOT_FOUND: { exitCode: 5, description: 'The requested resource was not found.' },
     POWERSYNC_OWNER_BUSY: { exitCode: 1, description: 'Another process owns the local PowerSync database.' },
     PRECONDITION_FAILED: { exitCode: 5, description: 'A safety precondition for the operation did not hold.' },
+    PROPERTY_DATE_INVALID: { exitCode: 1, description: 'A date property value is not a valid date.' },
+    PROPERTY_DEF_CONFIG_INVALID: { exitCode: 1, description: 'A property definition config is invalid.' },
+    PROPERTY_DEF_CONFIG_TYPE_MISMATCH: { exitCode: 1, description: 'A property definition config does not match the property type.' },
+    PROPERTY_DEF_ENSURE_FAILED: { exitCode: 1, description: 'The property definition could not be created or reused.' },
+    PROPERTY_DEF_ENSURE_INPUT_INVALID: { exitCode: 1, description: 'The property definition create input is invalid.' },
+    PROPERTY_DEF_NOT_FOUND: { exitCode: 5, description: 'The property definition does not exist or is deleted.' },
+    PROPERTY_DEF_TYPE_CONFLICT: { exitCode: 5, description: 'A property with this key already exists with a different type.' },
+    PROPERTY_DEF_TYPE_INVALID: { exitCode: 1, description: 'The stored property definition type is invalid.' },
+    PROPERTY_FILES_INVALID: { exitCode: 1, description: 'A files property value is invalid.' },
+    PROPERTY_LEGACY_OPTION_LABEL_INVALID: { exitCode: 1, description: 'A legacy option label cannot be migrated.' },
+    PROPERTY_LEGACY_OPTION_NOT_PLANNED: { exitCode: 1, description: 'A legacy option value was not covered by the migration plan.' },
+    PROPERTY_LEGACY_VALUE_INVALID: { exitCode: 1, description: 'A legacy option value cannot be migrated.' },
+    PROPERTY_MULTI_SELECT_EMPTY: { exitCode: 1, description: 'A multi-select property value is empty.' },
+    PROPERTY_MULTI_SELECT_LIMIT_EXCEEDED: { exitCode: 1, description: 'A multi-select property value has too many selections.' },
+    PROPERTY_NUMBER_INVALID: { exitCode: 1, description: 'A number property value is invalid or out of range.' },
+    PROPERTY_OPTIONS_INVALID: { exitCode: 1, description: 'Stored property options are invalid.' },
+    PROPERTY_OPTIONS_MIGRATION_REQUIRED: { exitCode: 5, description: 'Legacy property options must be migrated first (dino prop migrate-options).' },
+    PROPERTY_OPTIONS_TYPE_MISMATCH: { exitCode: 1, description: 'Options were supplied for a property type that has none.' },
+    PROPERTY_OPTION_ARCHIVED: { exitCode: 5, description: 'The select option is archived and cannot be assigned.' },
+    PROPERTY_OPTION_ID_DUPLICATE: { exitCode: 1, description: 'Property options contain duplicate ids.' },
+    PROPERTY_OPTION_ID_UNKNOWN: { exitCode: 1, description: 'A property option id does not exist on the definition.' },
+    PROPERTY_OPTION_LABEL_INVALID: { exitCode: 1, description: 'A property option label is blank, too long, or duplicated.' },
+    PROPERTY_OPTION_LIMIT_EXCEEDED: { exitCode: 1, description: 'The property has too many options.' },
+    PROPERTY_OPTION_NEW_ID_FORBIDDEN: { exitCode: 1, description: 'New property options must not carry an id.' },
+    PROPERTY_OPTION_NOT_FOUND: { exitCode: 5, description: 'The select option does not exist on a closed property.' },
+    PROPERTY_OPTION_REMOVAL_REQUIRES_ARCHIVE: { exitCode: 1, description: 'Existing property options must be archived instead of removed.' },
+    PROPERTY_OPTION_REPAIR_ID_FORBIDDEN: { exitCode: 1, description: 'Repair options must not carry ids.' },
+    PROPERTY_OPTION_SORT_RANK_EXHAUSTED: { exitCode: 1, description: 'No sort rank is left for a new property option.' },
+    PROPERTY_OPTION_VALUE_INVALID: { exitCode: 1, description: 'A select property value is invalid.' },
+    PROPERTY_PLACE_INVALID: { exitCode: 1, description: 'A place property value is invalid.' },
+    PROPERTY_RELATION_EMPTY: { exitCode: 1, description: 'A relation property value is empty.' },
+    PROPERTY_RELATION_INVALID: { exitCode: 1, description: 'A relation property value references invalid notes.' },
+    PROPERTY_RELATION_LIMIT: { exitCode: 1, description: 'A relation property value has too many notes.' },
+    PROPERTY_TYPE_NOT_ACTIVE: { exitCode: 1, description: 'The property type is not active.' },
+    PROPERTY_UNIQUE_ID_CONFIG_INVALID: { exitCode: 1, description: 'A unique-id property counter is invalid.' },
+    PROPERTY_UNIQUE_ID_INVALID: { exitCode: 1, description: 'A unique-id property value is invalid.' },
+    PROPERTY_UNIQUE_ID_TYPE_MISMATCH: { exitCode: 1, description: 'A unique-id setting was supplied for a different property type.' },
+    PROPERTY_URL_INVALID: { exitCode: 1, description: 'A url property value is invalid.' },
+    PROPERTY_VALUE_INVALID: { exitCode: 1, description: 'A property value does not match its definition.' },
+    SAVED_VIEW_FILTER_CORRUPT: { exitCode: 1, description: 'A stored saved view filter is corrupt.' },
     SAVED_VIEW_FILTER_TOO_COMPLEX: { exitCode: 1, description: 'The saved view filter exceeds supported complexity.' },
     SAVED_VIEW_FILTER_VALUE_REQUIRED: { exitCode: 5, description: 'A saved view filter condition is missing its value.' },
     SAVED_VIEW_INVALID_CONFIG: { exitCode: 1, description: 'The saved view config is invalid.' },
+    SAVED_VIEW_INVALID_CURRENT_TIME: { exitCode: 1, description: 'The reference time for dynamic date filters is invalid.' },
     SAVED_VIEW_INVALID_DATE_VALUE: { exitCode: 1, description: 'A saved view date value is not a real calendar date.' },
     SAVED_VIEW_INVALID_FIELD: { exitCode: 1, description: 'A saved view references an invalid field.' },
     SAVED_VIEW_INVALID_FILTER: { exitCode: 1, description: 'The saved view filter is invalid.' },
+    SAVED_VIEW_INVALID_OPERATOR: { exitCode: 1, description: 'A saved view filter operator is invalid.' },
+    SAVED_VIEW_INVALID_RELATIVE_DAYS: { exitCode: 1, description: 'withinLastDays requires an integer day count in range.' },
     SAVED_VIEW_INVALID_ROW: { exitCode: 1, description: 'A stored saved view row is invalid.' },
+    SAVED_VIEW_INVALID_TIME_ZONE: { exitCode: 2, description: 'The time zone is not a valid IANA time zone.' },
     SAVED_VIEW_NOT_FOUND: { exitCode: 5, description: 'The saved view does not exist.' },
     SAVED_VIEW_OPERATOR_TYPE_MISMATCH: { exitCode: 1, description: 'A filter operator is not valid for the field type.' },
     SAVED_VIEW_OPTION_NOT_FOUND: { exitCode: 5, description: 'A select option id referenced by the view does not exist.' },
@@ -55,6 +107,7 @@ export const ERROR_CODES = {
     SAVED_VIEW_PROPERTY_OPTIONS_INVALID: { exitCode: 1, description: 'Property options used by the view are invalid.' },
     SAVED_VIEW_PROPERTY_OPTIONS_MIGRATION_REQUIRED: { exitCode: 5, description: 'Property options need migration before use.' },
     SAVED_VIEW_SORT_TYPE_UNSUPPORTED: { exitCode: 1, description: 'The field type cannot be sorted.' },
+    SAVED_VIEW_TIME_ZONE_CONVERSION_FAILED: { exitCode: 1, description: 'A dynamic date boundary could not be converted to the time zone.' },
     SAVED_VIEW_UNSUPPORTED_CONFIG_VERSION: { exitCode: 1, description: 'The saved view config version is unsupported.' },
     SAVED_VIEW_UNSUPPORTED_FILTER_VERSION: { exitCode: 1, description: 'The saved view filter version is unsupported.' },
     SAVED_VIEW_UNSUPPORTED_LAYOUT: { exitCode: 1, description: 'The saved view layout is unsupported.' },

package/dist/vendor/electron/domain/note-templates.d.ts

@@ -0,0 +1,3 @@
+import { type CommandDefinition, type ReadModelDefinition } from "../rpc.js";
+export declare function createNoteTemplateReadModels(): ReadModelDefinition[];
+export declare function createNoteTemplateCommands(): CommandDefinition[];

package/dist/vendor/electron/domain/note-templates.js

@@ -0,0 +1,232 @@
+import { isPropertyKeyValid, serializeNoteTemplatePropertyKeys, } from "../shared/index.js";
+import { uuidv7 } from "uuidv7";
+import { z } from "zod";
+import { defineCommand, defineReadModel, } from "../rpc.js";
+import { normalizeLimit } from "../sql-utils.js";
+/**
+ * Note templates are synced rows shared with the mobile client. The electron
+ * side owns the `property_def` column (versioned key-list envelope); writes
+ * only SET the columns they change so template content/extra_data written by
+ * other clients is never clobbered.
+ */
+const NOTE_TEMPLATE_TABLE = "c_note_template";
+const NOTE_TEMPLATE_COLUMNS = `
+	id, user_id, name, content, priority, is_show, extra_data, property_def,
+	insert_at, update_at, is_del
+`;
+const PROPERTY_KEYS_INPUT = z
+    .array(z.string().min(1).max(64).refine(isPropertyKeyValid))
+    .max(50);
+const NOTE_TEMPLATE_CATALOG_INPUT = z.object({
+    userId: z.string().trim().min(1),
+    limit: z.number().int().positive().max(2000).optional(),
+});
+const TEMPLATE_CONTENT_INPUT = z.string().max(200_000);
+const NOTE_TEMPLATE_CREATE_INPUT = z.object({
+    userId: z.string().trim().min(1),
+    name: z.string().trim().min(1).max(120),
+    propertyKeys: PROPERTY_KEYS_INPUT,
+    content: TEMPLATE_CONTENT_INPUT.nullable().optional(),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const NOTE_TEMPLATE_UPDATE_INPUT = z
+    .object({
+    id: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    name: z.string().trim().min(1).max(120).optional(),
+    propertyKeys: PROPERTY_KEYS_INPUT.optional(),
+    content: TEMPLATE_CONTENT_INPUT.nullable().optional(),
+    updatedAt: z.string().trim().min(1).max(64),
+})
+    .refine((input) => input.name !== undefined ||
+    input.propertyKeys !== undefined ||
+    input.content !== undefined, {
+    message: "At least one note-template field must be updated",
+});
+const NOTE_TEMPLATE_SOFT_DELETE_INPUT = z.object({
+    id: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+export function createNoteTemplateReadModels() {
+    return [
+        defineReadModel({
+            name: "noteTemplates.catalog",
+            inputSchema: NOTE_TEMPLATE_CATALOG_INPUT,
+            tables: () => [NOTE_TEMPLATE_TABLE],
+            fetch: async (db, input) => fetchNoteTemplateCatalog(db, input),
+        }),
+    ];
+}
+export function createNoteTemplateCommands() {
+    return [
+        defineCommand({
+            name: "noteTemplates.create",
+            inputSchema: NOTE_TEMPLATE_CREATE_INPUT,
+            run: async (db, input) => {
+                const id = await createNoteTemplate(db, input);
+                return { result: id, affectedTables: [NOTE_TEMPLATE_TABLE] };
+            },
+        }),
+        defineCommand({
+            name: "noteTemplates.update",
+            inputSchema: NOTE_TEMPLATE_UPDATE_INPUT,
+            run: async (db, input) => {
+                const changed = await updateNoteTemplate(db, input);
+                return {
+                    result: changed,
+                    affectedTables: changed ? [NOTE_TEMPLATE_TABLE] : [],
+                };
+            },
+        }),
+        defineCommand({
+            name: "noteTemplates.softDelete",
+            inputSchema: NOTE_TEMPLATE_SOFT_DELETE_INPUT,
+            run: async (db, input) => {
+                const changed = await softDeleteNoteTemplate(db, input);
+                return {
+                    result: changed,
+                    affectedTables: changed ? [NOTE_TEMPLATE_TABLE] : [],
+                };
+            },
+        }),
+    ];
+}
+async function fetchNoteTemplateCatalog(db, input) {
+    const userId = input.userId.trim();
+    const limit = normalizeLimit(input.limit, 500, 2000);
+    if (!userId)
+        throw new Error("Invalid note template catalog input");
+    if (limit <= 0)
+        return [];
+    return await db.getAll(`
+	      SELECT ${NOTE_TEMPLATE_COLUMNS}
+	      FROM c_note_template
+	      WHERE user_id = ?
+	        AND (is_del IS NULL OR is_del = 0)
+	      ORDER BY COALESCE(priority, 0) ASC,
+	        COALESCE(NULLIF(insert_at, ''), id) ASC,
+	        id ASC
+	      LIMIT ?
+	    `, [userId, limit]);
+}
+function normalizeTemplateContent(content) {
+    if (typeof content !== "string")
+        return "";
+    return content.trim() ? content : "";
+}
+/**
+ * Templates with content are visible in the mobile template picker
+ * (is_show = 1); property-only templates stay hidden there (is_show = 0)
+ * because mobile does not render property_def yet and an empty-content
+ * template would produce blank notes.
+ */
+async function createNoteTemplate(db, input) {
+    const userId = input.userId.trim();
+    const name = input.name.trim();
+    const updatedAt = input.updatedAt.trim();
+    if (!userId || !name || !updatedAt) {
+        throw new Error("Invalid note template create input");
+    }
+    const content = normalizeTemplateContent(input.content);
+    const id = uuidv7();
+    await db.writeTransaction(async (context) => {
+        await context.execute(`INSERT INTO c_note_template (
+		        id, user_id, name, content, priority, is_show, extra_data,
+		        property_def, insert_at, update_at, is_del
+		      ) VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, 0)
+		    `, [
+            id,
+            userId,
+            name,
+            content,
+            content ? 1 : 0,
+            "{}",
+            serializeNoteTemplatePropertyKeys(input.propertyKeys),
+            updatedAt,
+            updatedAt,
+        ]);
+    });
+    return id;
+}
+async function updateNoteTemplate(db, input) {
+    const id = input.id.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    if (!id || !userId || !updatedAt) {
+        throw new Error("Invalid note template update input");
+    }
+    let changed = false;
+    await db.writeTransaction(async (context) => {
+        const row = await context.getOptional(`SELECT ${NOTE_TEMPLATE_COLUMNS}
+			 FROM c_note_template
+			 WHERE id = ?
+			   AND user_id = ?
+			   AND (is_del IS NULL OR is_del = 0)
+			 LIMIT 1`, [id, userId]);
+        if (!row)
+            return;
+        const assignments = [];
+        const params = [];
+        if (input.name !== undefined) {
+            const name = input.name.trim();
+            if (name && name !== (row.name ?? "")) {
+                assignments.push("name = ?");
+                params.push(name);
+            }
+        }
+        if (input.propertyKeys !== undefined) {
+            const serialized = serializeNoteTemplatePropertyKeys(input.propertyKeys);
+            if (serialized !== (row.property_def ?? null)) {
+                assignments.push("property_def = ?");
+                params.push(serialized);
+            }
+        }
+        if (input.content !== undefined) {
+            const nextContent = normalizeTemplateContent(input.content);
+            const previousContent = normalizeTemplateContent(row.content);
+            if (nextContent !== previousContent) {
+                assignments.push("content = ?");
+                params.push(nextContent);
+                // Flip mobile-picker visibility only when content presence changes,
+                // so a manual is_show choice survives ordinary edits.
+                if (Boolean(nextContent) !== Boolean(previousContent)) {
+                    assignments.push("is_show = ?");
+                    params.push(nextContent ? 1 : 0);
+                }
+            }
+        }
+        if (assignments.length === 0)
+            return;
+        assignments.push("update_at = ?");
+        params.push(updatedAt, id, userId);
+        await context.execute(`UPDATE c_note_template
+			 SET ${assignments.join(", ")}
+			 WHERE id = ? AND user_id = ?`, params);
+        changed = true;
+    });
+    return changed;
+}
+async function softDeleteNoteTemplate(db, input) {
+    const id = input.id.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    if (!id || !userId || !updatedAt) {
+        throw new Error("Invalid note template delete input");
+    }
+    let changed = false;
+    await db.writeTransaction(async (context) => {
+        const row = await context.getOptional(`SELECT id FROM c_note_template
+			 WHERE id = ?
+			   AND user_id = ?
+			   AND (is_del IS NULL OR is_del = 0)
+			 LIMIT 1`, [id, userId]);
+        if (!row)
+            return;
+        await context.execute(`UPDATE c_note_template
+			 SET is_del = 1, update_at = ?
+			 WHERE id = ? AND user_id = ?`, [updatedAt, id, userId]);
+        changed = true;
+    });
+    return changed;
+}