@dinoxx/dinox-cli 2.2.0 → 2.4.0

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

@@ -0,0 +1,150 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type ActivePropertyType, type NotePropertiesFillEmptyResult, type NotePropertiesPatch, type NoteProperties, type NotePropertySlotOperation, type NotePropertyValue, type PropertyDef, type PropertyDefConfig, type PropertyDefMigrateLegacyOptionsResult, type PropertyDefSource, type PropertyOptionInput, type PropertyType } from '../../vendor/electron/shared/index.js';
+export declare function listProperties(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    limit?: number;
+}): Promise<PropertyDef[]>;
+/** Resolves a definition by id, falling back to key (keys are unique among active defs). */
+export declare function findProperty(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    ref: string;
+}): Promise<PropertyDef | null>;
+export declare function requireProperty(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    ref: string;
+}): Promise<PropertyDef>;
+export type PropertyCreateInput = {
+    userId: string;
+    key: string;
+    name?: string;
+    type?: ActivePropertyType;
+    optionItems?: PropertyOptionInput[];
+    uniqueIdPrefix?: string;
+    config?: PropertyDefConfig;
+    description?: string;
+    icon?: string;
+    source?: PropertyDefSource;
+};
+export type PropertyCreateResult = {
+    property: PropertyDef;
+    created: boolean;
+};
+export declare function createProperty(db: AbstractPowerSyncDatabase, input: PropertyCreateInput): Promise<PropertyCreateResult>;
+export declare function previewCreateProperty(db: AbstractPowerSyncDatabase, input: PropertyCreateInput): Promise<PropertyCreateResult>;
+export type OptionEdit = {
+    kind: 'add';
+    label: string;
+    color?: PropertyOptionInput['color'];
+    group?: PropertyOptionInput['group'];
+} | {
+    kind: 'archive' | 'restore';
+    ref: string;
+} | {
+    kind: 'rename';
+    ref: string;
+    label: string;
+} | {
+    kind: 'color';
+    ref: string;
+    color: NonNullable<PropertyOptionInput['color']>;
+};
+export type PropertyConfigureInput = {
+    userId: string;
+    ref: string;
+    name?: string | null;
+    description?: string | null;
+    icon?: string | null;
+    showOnCard?: boolean;
+    sortRank?: number | null;
+    options?: PropertyOptionInput[];
+    optionEdits?: OptionEdit[];
+    uniqueIdPrefix?: string;
+    repairInvalidOptions?: boolean;
+    config?: PropertyDefConfig | null;
+};
+/** Applies add/archive/restore/rename/color edits onto the complete current option list. */
+export declare function applyOptionEdits(definition: PropertyDef, edits: readonly OptionEdit[]): PropertyOptionInput[];
+export declare function configureProperty(db: AbstractPowerSyncDatabase, input: PropertyConfigureInput): Promise<{
+    property: PropertyDef;
+    changed: boolean;
+}>;
+export declare function previewConfigureProperty(db: AbstractPowerSyncDatabase, input: PropertyConfigureInput): Promise<{
+    property: PropertyDef;
+    changed: boolean;
+    before: PropertyDef;
+}>;
+export declare function deleteProperty(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    ref: string;
+}): Promise<PropertyDef>;
+export declare function previewDeleteProperty(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    ref: string;
+}): Promise<PropertyDef>;
+export declare function migrationAffectedCount(result: PropertyDefMigrateLegacyOptionsResult): number;
+export declare function previewMigrateLegacyOptions(db: AbstractPowerSyncDatabase, userId: string): Promise<PropertyDefMigrateLegacyOptionsResult>;
+/** Runs the migration and rolls it back unless it touches exactly `expectedCount` records. */
+export declare function migrateLegacyOptions(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    expectedCount: number;
+}): Promise<PropertyDefMigrateLegacyOptionsResult>;
+export type NotePropertyEntry = {
+    key: string;
+    name: string;
+    type: PropertyType;
+    /** False when the key has no active definition; its type is inferred from the value. */
+    defined: boolean;
+    propertyDefinitionId: string | null;
+    /** Null marks a declared-but-empty slot. */
+    value: NotePropertyValue | null;
+    display: unknown;
+};
+export type NotePropertiesView = {
+    noteId: string;
+    /** False when the stored JSON is corrupt; writes are refused until it is repaired. */
+    valid: boolean;
+    properties: Record<string, NotePropertyValue | null>;
+    entries: NotePropertyEntry[];
+};
+export declare function readNoteProperties(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    noteId: string;
+}): Promise<NotePropertiesView>;
+export type NotePropertyMutationResult = {
+    changed: boolean;
+    before: NotePropertiesView;
+    after: NotePropertiesView;
+};
+export declare function setNoteProperties(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    noteId: string;
+    patch: NotePropertiesPatch;
+    dryRun?: boolean;
+}): Promise<NotePropertyMutationResult & {
+    result: import("../domain/run.js").DomainCommandResult<boolean>;
+}>;
+export declare function fillEmptyNoteProperties(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    noteId: string;
+    values: NoteProperties;
+    dryRun?: boolean;
+}): Promise<NotePropertyMutationResult & {
+    result: NotePropertiesFillEmptyResult;
+}>;
+export declare function updateNotePropertySlots(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    noteId: string;
+    operation: NotePropertySlotOperation;
+    keys: string[];
+    dryRun?: boolean;
+}): Promise<NotePropertyMutationResult & {
+    result: import("../domain/run.js").DomainCommandResult<boolean>;
+}>;
+export declare function reorderNotePropertySlots(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    noteId: string;
+    orderedKeys: string[];
+    dryRun?: boolean;
+}): Promise<NotePropertyMutationResult & {
+    result: import("../domain/run.js").DomainCommandResult<boolean>;
+}>;

package/dist/commands/properties/repo.js

@@ -0,0 +1,272 @@
+// Property definitions (`c_property_def` + companion `c_config_property` rows) and note
+// property values (`c_note.properties`), mutated through the vendored desktop commands so
+// option ids, unique-id counters, config envelopes, and value coercion match Dinox desktop.
+import { DinoxError } from '../../utils/errors.js';
+import { findPropertyOptionById, findPropertyOptionByLabel, formatPropertyValue, inferPropertyTypeFromValue, mapPropertyDef, parseStoredNoteProperties, tryParseRawNoteProperties, } from '../../vendor/electron/shared/index.js';
+import { fetchDomainReadModel, previewInRolledBackTransaction, runDomainCommand, withNestedWriteTransaction, } from '../domain/run.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+export async function listProperties(db, input) {
+    const rows = await fetchDomainReadModel(db, 'properties.catalog', {
+        userId: input.userId,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+    });
+    return rows.map(mapPropertyDef);
+}
+/** Resolves a definition by id, falling back to key (keys are unique among active defs). */
+export async function findProperty(db, input) {
+    const ref = input.ref.trim();
+    const definitions = await listProperties(db, { userId: input.userId, limit: 5000 });
+    return definitions.find((definition) => definition.id === ref)
+        ?? definitions.find((definition) => definition.key === ref)
+        ?? null;
+}
+export async function requireProperty(db, input) {
+    const definition = await findProperty(db, input);
+    if (!definition) {
+        throw new DinoxError(`Property definition not found: ${input.ref}`, {
+            code: 'PROPERTY_DEF_NOT_FOUND',
+            details: { ref: input.ref },
+            suggestion: 'Run `dino prop list --format json` to see property ids and keys.',
+        });
+    }
+    return definition;
+}
+async function runCreate(db, input) {
+    const existing = await findProperty(db, { userId: input.userId, ref: input.key });
+    const { result: id } = await runDomainCommand(db, 'properties.ensure', {
+        key: input.key,
+        userId: input.userId,
+        updatedAt: nowIso(),
+        ...(input.name === undefined ? {} : { name: input.name }),
+        ...(input.type === undefined ? {} : { type: input.type }),
+        ...(input.optionItems === undefined ? {} : { optionItems: input.optionItems }),
+        ...(input.uniqueIdPrefix === undefined ? {} : { uniqueIdPrefix: input.uniqueIdPrefix }),
+        ...(input.config === undefined ? {} : { config: input.config }),
+        ...(input.description === undefined ? {} : { description: input.description }),
+        ...(input.icon === undefined ? {} : { icon: input.icon }),
+        ...(input.source === undefined ? {} : { source: input.source }),
+    });
+    const property = await requireProperty(db, { userId: input.userId, ref: id });
+    return { property, created: existing?.id !== id };
+}
+export async function createProperty(db, input) {
+    return runCreate(db, input);
+}
+export async function previewCreateProperty(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runCreate(tx, input), async (_tx, result) => result);
+}
+function resolveOption(definition, ref) {
+    const options = definition.options ?? [];
+    const option = findPropertyOptionById(options, ref) ?? findPropertyOptionByLabel(options, ref);
+    if (!option) {
+        throw new DinoxError(`Option not found on property ${definition.key}: ${ref}`, {
+            code: 'PROPERTY_OPTION_NOT_FOUND',
+            details: { property: definition.key, option: ref },
+        });
+    }
+    return option;
+}
+/** Applies add/archive/restore/rename/color edits onto the complete current option list. */
+export function applyOptionEdits(definition, edits) {
+    if (definition.optionsMigrationPending) {
+        throw new DinoxError('Legacy property options must be migrated first', { code: 'PROPERTY_OPTIONS_MIGRATION_REQUIRED' });
+    }
+    const next = (definition.options ?? []).map((option) => ({
+        id: option.id,
+        label: option.label,
+        color: option.color,
+        sortRank: option.sortRank,
+        archived: option.archived,
+        ...(option.group ? { group: option.group } : {}),
+    }));
+    const byId = (id) => next.find((option) => option.id === id);
+    for (const edit of edits) {
+        if (edit.kind === 'add') {
+            next.push({ label: edit.label, ...(edit.color ? { color: edit.color } : {}), ...(edit.group ? { group: edit.group } : {}) });
+            continue;
+        }
+        const target = byId(resolveOption(definition, edit.ref).id);
+        if (edit.kind === 'archive')
+            target.archived = true;
+        if (edit.kind === 'restore')
+            target.archived = false;
+        if (edit.kind === 'rename')
+            target.label = edit.label;
+        if (edit.kind === 'color')
+            target.color = edit.color;
+    }
+    return next;
+}
+async function runConfigure(db, input) {
+    const definition = await requireProperty(db, { userId: input.userId, ref: input.ref });
+    const options = input.optionEdits && input.optionEdits.length > 0
+        ? applyOptionEdits(definition, input.optionEdits)
+        : input.options;
+    const { result: changed } = await runDomainCommand(db, 'properties.configure', {
+        id: definition.id,
+        userId: input.userId,
+        updatedAt: nowIso(),
+        ...(input.name === undefined ? {} : { name: input.name }),
+        ...(input.description === undefined ? {} : { description: input.description }),
+        ...(input.icon === undefined ? {} : { icon: input.icon }),
+        ...(input.showOnCard === undefined ? {} : { showOnCard: input.showOnCard }),
+        ...(input.sortRank === undefined ? {} : { sortRank: input.sortRank }),
+        ...(options === undefined ? {} : { options }),
+        ...(input.uniqueIdPrefix === undefined ? {} : { uniqueIdPrefix: input.uniqueIdPrefix }),
+        ...(input.repairInvalidOptions ? { repairInvalidOptions: true } : {}),
+        ...(input.config === undefined ? {} : { config: input.config }),
+    });
+    return { property: await requireProperty(db, { userId: input.userId, ref: definition.id }), changed };
+}
+export async function configureProperty(db, input) {
+    return runConfigure(db, input);
+}
+export async function previewConfigureProperty(db, input) {
+    const before = await requireProperty(db, { userId: input.userId, ref: input.ref });
+    return previewInRolledBackTransaction(db, (tx) => runConfigure(tx, input), async (_tx, result) => ({ before, ...result }));
+}
+async function runDelete(db, input) {
+    const definition = await requireProperty(db, input);
+    await runDomainCommand(db, 'properties.softDelete', {
+        id: definition.id,
+        userId: input.userId,
+        updatedAt: nowIso(),
+    });
+    return definition;
+}
+export async function deleteProperty(db, input) {
+    return runDelete(db, input);
+}
+export async function previewDeleteProperty(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runDelete(tx, input), async (_tx, definition) => definition);
+}
+async function runMigrate(db, userId) {
+    const { result } = await runDomainCommand(db, 'properties.migrateLegacyOptions', {
+        userId,
+        updatedAt: nowIso(),
+    });
+    return result;
+}
+export function migrationAffectedCount(result) {
+    return result.definitionsMigrated + result.notesUpdated + result.savedViewsUpdated;
+}
+export async function previewMigrateLegacyOptions(db, userId) {
+    return previewInRolledBackTransaction(db, (tx) => runMigrate(tx, userId), async (_tx, result) => result);
+}
+/** Runs the migration and rolls it back unless it touches exactly `expectedCount` records. */
+export async function migrateLegacyOptions(db, input) {
+    return withNestedWriteTransaction(db, async (tx) => {
+        const result = await runMigrate(tx, input.userId);
+        const actualCount = migrationAffectedCount(result);
+        if (actualCount !== input.expectedCount) {
+            throw new DinoxError(`--expected-count ${input.expectedCount} does not match current affected record count ${actualCount}`, {
+                code: 'PRECONDITION_FAILED',
+                details: { expectedCount: input.expectedCount, actualCount, result },
+                suggestion: 'Re-run `dino prop migrate-options --dry-run --format json` and retry with changes.affected_count.',
+            });
+        }
+        return result;
+    });
+}
+function displayEntryValue(definition, value) {
+    if (value === null)
+        return null;
+    const options = definition?.options;
+    if (options && (definition.type === 'select' || definition.type === 'status') && typeof value === 'string') {
+        const option = findPropertyOptionById(options, value);
+        return option ? { id: option.id, label: option.label, color: option.color, archived: option.archived, ...(option.group ? { group: option.group } : {}) } : { id: value, label: null, unknown: true };
+    }
+    if (options && definition.type === 'multi_select' && Array.isArray(value)) {
+        return value.map((item) => {
+            const option = findPropertyOptionById(options, item);
+            return option ? { id: option.id, label: option.label, color: option.color, archived: option.archived } : { id: item, label: null, unknown: true };
+        });
+    }
+    if (definition?.type === 'unique_id' && typeof value === 'number' && definition.uniqueId) {
+        return `${definition.uniqueId.prefix}-${value}`;
+    }
+    return formatPropertyValue(value);
+}
+export async function readNoteProperties(db, input) {
+    const row = await db.getOptional(`
+      SELECT id, properties
+      FROM c_note
+      WHERE id = ? AND user_no = ? AND (is_del IS NULL OR is_del = 0)
+      LIMIT 1
+    `, [input.noteId, input.userId]);
+    if (!row) {
+        throw new DinoxError(`Note not found: ${input.noteId}`, { code: 'NOTE_NOT_FOUND', details: { noteId: input.noteId } });
+    }
+    const definitions = new Map((await listProperties(db, { userId: input.userId, limit: 5000 })).map((definition) => [definition.key, definition]));
+    const properties = parseStoredNoteProperties(row.properties);
+    const entries = Object.entries(properties).map(([key, value]) => {
+        const definition = definitions.get(key);
+        return {
+            key,
+            name: definition?.name || key,
+            type: definition?.type ?? (value === null ? 'text' : inferPropertyTypeFromValue(value)),
+            defined: Boolean(definition),
+            propertyDefinitionId: definition?.id ?? null,
+            value,
+            display: displayEntryValue(definition, value),
+        };
+    });
+    return {
+        noteId: row.id,
+        valid: tryParseRawNoteProperties(row.properties) !== null,
+        properties,
+        entries,
+    };
+}
+async function mutate(db, input, run, dryRun) {
+    const before = await readNoteProperties(db, input);
+    const execute = async (tx) => {
+        const result = await run(tx);
+        const after = await readNoteProperties(tx, input);
+        return { result, after };
+    };
+    const { result, after } = dryRun
+        ? await previewInRolledBackTransaction(db, execute, async (_tx, value) => value)
+        : await execute(db);
+    return {
+        result,
+        changed: JSON.stringify(before.properties) !== JSON.stringify(after.properties),
+        before,
+        after,
+    };
+}
+export async function setNoteProperties(db, input) {
+    return mutate(db, input, (tx) => runDomainCommand(tx, 'notes.updateProperties', {
+        noteId: input.noteId,
+        userId: input.userId,
+        patch: input.patch,
+        updatedAt: nowIso(),
+    }), Boolean(input.dryRun));
+}
+export async function fillEmptyNoteProperties(db, input) {
+    return mutate(db, input, async (tx) => (await runDomainCommand(tx, 'notes.fillEmptyProperties', {
+        noteId: input.noteId,
+        userId: input.userId,
+        values: input.values,
+        updatedAt: nowIso(),
+    })).result, Boolean(input.dryRun));
+}
+export async function updateNotePropertySlots(db, input) {
+    return mutate(db, input, (tx) => runDomainCommand(tx, 'notes.updatePropertySlots', {
+        noteId: input.noteId,
+        userId: input.userId,
+        operation: input.operation,
+        keys: input.keys,
+        updatedAt: nowIso(),
+    }), Boolean(input.dryRun));
+}
+export async function reorderNotePropertySlots(db, input) {
+    return mutate(db, input, (tx) => runDomainCommand(tx, 'notes.reorderPropertySlots', {
+        noteId: input.noteId,
+        userId: input.userId,
+        orderedKeys: input.orderedKeys,
+        updatedAt: nowIso(),
+    }), Boolean(input.dryRun));
+}

package/dist/commands/savedViews/fields.d.ts

@@ -0,0 +1,28 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type PropertyDef, type PropertyDefConfig, type PropertyOption, type PropertyType, type SavedViewFieldRef } from '../../vendor/electron/shared/index.js';
+export type SavedViewFieldValueType = 'text' | 'select' | 'list' | 'number' | 'date' | 'boolean';
+export type SavedViewFieldCatalogItem = {
+    field: SavedViewFieldRef;
+    name: string;
+    /** How filter values are compared: select/list values are option ids (or note/box ids). */
+    type: SavedViewFieldValueType;
+    propertyType: PropertyType;
+    sortable: boolean;
+    filterable: boolean;
+    displayOnly: boolean;
+    filterOperators: string[];
+    available: boolean;
+    error?: {
+        code: string;
+        message: string;
+    };
+    options?: readonly PropertyOption[];
+    values?: readonly string[];
+    config?: PropertyDefConfig;
+    propertyDefinitionId?: string;
+    description?: string | null;
+    icon?: string | null;
+};
+export declare function valueTypeForPropertyType(type: PropertyType): SavedViewFieldValueType;
+export declare function listPropertyDefinitions(db: AbstractPowerSyncDatabase, userId: string, limit?: number): Promise<PropertyDef[]>;
+export declare function listSavedViewFields(db: AbstractPowerSyncDatabase, userId: string): Promise<SavedViewFieldCatalogItem[]>;

package/dist/commands/savedViews/fields.js

@@ -0,0 +1,87 @@
+// Field catalog for saved views: system fields plus the account's property definitions,
+// each with the operators and sortability the desktop editor offers for it.
+import { canSortSavedViewField, getSavedViewFilterOperatorsForField, isSavedViewDisplayOnlyField, mapPropertyDef, SAVED_VIEW_PRIMARY_RESOURCE_TYPES, SAVED_VIEW_SYSTEM_FIELDS, } from '../../vendor/electron/shared/index.js';
+import { fetchDomainReadModel } from '../domain/run.js';
+const SYSTEM_FIELD_META = {
+    'sys.title': { name: 'Title', propertyType: 'text', type: 'text' },
+    'sys.created_at': { name: 'Created at', propertyType: 'date', type: 'date' },
+    'sys.updated_at': { name: 'Updated at', propertyType: 'date', type: 'date' },
+    'sys.tags': { name: 'Tags', propertyType: 'multi_select', type: 'list' },
+    'sys.zettel_boxes': { name: 'Zettel boxes', propertyType: 'relation', type: 'list' },
+    'sys.source': { name: 'Source', propertyType: 'text', type: 'text' },
+    'sys.type': { name: 'Type', propertyType: 'text', type: 'text' },
+    'sys.primary_resource_type': { name: 'Primary resource type', propertyType: 'select', type: 'select' },
+    'sys.starred_at': { name: 'Starred at', propertyType: 'date', type: 'date' },
+    'sys.images': { name: 'Images', propertyType: 'text', type: 'text' },
+    'sys.cover': { name: 'Cover', propertyType: 'text', type: 'text' },
+    'sys.audio': { name: 'Audio', propertyType: 'text', type: 'text' },
+    'sys.video': { name: 'Video', propertyType: 'text', type: 'text' },
+    'sys.file': { name: 'File', propertyType: 'text', type: 'text' },
+};
+export function valueTypeForPropertyType(type) {
+    switch (type) {
+        case 'number':
+        case 'unique_id':
+            return 'number';
+        case 'date':
+            return 'date';
+        case 'select':
+        case 'status':
+            return 'select';
+        case 'checkbox':
+            return 'boolean';
+        case 'multi_select':
+        case 'relation':
+            return 'list';
+        default:
+            return 'text';
+    }
+}
+function catalogItem(field, name, propertyType, type) {
+    const displayOnly = isSavedViewDisplayOnlyField(field);
+    const filterOperators = getSavedViewFilterOperatorsForField(field, propertyType);
+    return {
+        field,
+        name,
+        type,
+        propertyType,
+        sortable: canSortSavedViewField(field, propertyType),
+        filterable: filterOperators.length > 0,
+        displayOnly,
+        filterOperators,
+        available: true,
+    };
+}
+function propertyItem(definition) {
+    const field = `prop.${definition.key}`;
+    const item = {
+        ...catalogItem(field, definition.name || definition.key, definition.type, valueTypeForPropertyType(definition.type)),
+        propertyDefinitionId: definition.id,
+        description: definition.description ?? null,
+        icon: definition.icon ?? null,
+        ...(definition.options ? { options: definition.options } : {}),
+        ...(definition.config ? { config: definition.config } : {}),
+    };
+    const error = definition.optionsMigrationPending
+        ? { code: 'PROPERTY_OPTIONS_MIGRATION_REQUIRED', message: 'Legacy select options must be migrated first (dino prop migrate-options)' }
+        : definition.optionsInvalid
+            ? { code: 'PROPERTY_OPTIONS_INVALID', message: 'Stored property options are invalid' }
+            : definition.configInvalid
+                ? { code: 'PROPERTY_DEF_CONFIG_INVALID', message: 'Stored property config is invalid' }
+                : null;
+    return error ? { ...item, available: false, error } : item;
+}
+export async function listPropertyDefinitions(db, userId, limit) {
+    const rows = await fetchDomainReadModel(db, 'properties.catalog', { userId, ...(limit ? { limit } : {}) });
+    return rows.map(mapPropertyDef);
+}
+export async function listSavedViewFields(db, userId) {
+    const systemItems = SAVED_VIEW_SYSTEM_FIELDS.map((name) => {
+        const field = `sys.${name}`;
+        const meta = SYSTEM_FIELD_META[field] ?? { name, propertyType: 'text', type: 'text' };
+        const item = catalogItem(field, meta.name, meta.propertyType, meta.type);
+        return field === 'sys.primary_resource_type' ? { ...item, values: SAVED_VIEW_PRIMARY_RESOURCE_TYPES } : item;
+    });
+    const definitions = await listPropertyDefinitions(db, userId);
+    return [...systemItems, ...definitions.map(propertyItem)];
+}