@dinoxx/dinox-cli 1.0.0

package/dist/commands/notes/searchTime.js

@@ -0,0 +1,85 @@
+import { DinoxError } from '../../utils/errors.js';
+const DATE_ONLY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DAY_MS = 24 * 60 * 60 * 1000;
+function parseUtcDateOnly(value) {
+    const match = value.match(DATE_ONLY_RE);
+    if (!match) {
+        return null;
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const utc = new Date(Date.UTC(year, month - 1, day));
+    if (utc.getUTCFullYear() !== year ||
+        utc.getUTCMonth() !== month - 1 ||
+        utc.getUTCDate() !== day) {
+        return null;
+    }
+    return utc;
+}
+function parseDateInput(value, optionName) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const raw = value.trim();
+    if (!raw) {
+        throw new DinoxError(`${optionName} requires a non-empty date value`);
+    }
+    const isDateOnly = DATE_ONLY_RE.test(raw);
+    const dateOnly = parseUtcDateOnly(raw);
+    if (dateOnly) {
+        if (optionName === '--from') {
+            return dateOnly.toISOString();
+        }
+        return new Date(dateOnly.getTime() + DAY_MS - 1).toISOString();
+    }
+    if (isDateOnly) {
+        throw new DinoxError(`${optionName} must be a valid date (YYYY-MM-DD or ISO datetime)`);
+    }
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new DinoxError(`${optionName} must be a valid date (YYYY-MM-DD or ISO datetime)`);
+    }
+    return parsed.toISOString();
+}
+function parseDaysInput(value) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--days must be a positive integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--days must be a positive integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--days must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+export function parseCreatedAtRange(input, now = new Date()) {
+    const from = parseDateInput(input.from, '--from');
+    const to = parseDateInput(input.to, '--to');
+    const days = parseDaysInput(input.days);
+    if (days !== undefined && (from || to)) {
+        throw new DinoxError('--days cannot be used together with --from/--to');
+    }
+    if (days !== undefined) {
+        const nowIso = now.toISOString();
+        const todayUtcStart = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), 0, 0, 0, 0);
+        const fromUtc = new Date(todayUtcStart - (days - 1) * DAY_MS).toISOString();
+        return {
+            createdAtFrom: fromUtc,
+            createdAtTo: nowIso,
+        };
+    }
+    if (from && to && from > to) {
+        throw new DinoxError('--from must be earlier than or equal to --to');
+    }
+    return {
+        createdAtFrom: from,
+        createdAtTo: to,
+    };
+}

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerPromptCommands(program: Command): void;

package/dist/commands/prompt/index.js

@@ -0,0 +1,51 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { DinoxError } from '../../utils/errors.js';
+import { printYaml } from '../../utils/output.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
+import { listPrompts } from './repo.js';
+function parseSyncTimeoutMs(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+async function syncBeforePromptCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+    await syncNoteTokenIndex(db);
+}
+async function runPromptListCommand(options, command) {
+    const globals = command.optsWithGlobals?.() ?? {};
+    const offline = Boolean(options.offline ?? globals.offline);
+    const config = resolveConfig(await loadConfig());
+    const timeoutMs = parseSyncTimeoutMs(options.syncTimeout ?? globals.syncTimeout) ?? config.sync.timeoutMs;
+    const { db } = await connectPowerSync({ config, offline, timeoutMs });
+    try {
+        await syncBeforePromptCommand(db, offline, timeoutMs);
+        const prompts = await listPrompts(db);
+        printYaml(prompts);
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+export function registerPromptCommands(program) {
+    const prompt = program.command('prompt').description('Manage prompts');
+    prompt
+        .command('list')
+        .description('List prompts from c_cmd (name and cmd)')
+        .option('--offline', 'skip connect/sync and only use local cache')
+        .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
+        .action(runPromptListCommand);
+    prompt.action((_options, command) => {
+        command.outputHelp();
+    });
+}

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

@@ -0,0 +1,6 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export type PromptListItem = {
+    name: string;
+    cmd: string;
+};
+export declare function listPrompts(db: AbstractPowerSyncDatabase): Promise<PromptListItem[]>;

package/dist/commands/prompt/repo.js

@@ -0,0 +1,18 @@
+export async function listPrompts(db) {
+    const rows = await db.getAll(`
+    SELECT DISTINCT
+      TRIM(COALESCE(name, '')) AS name,
+      TRIM(COALESCE(cmd, '')) AS cmd
+    FROM c_cmd
+    WHERE (is_del IS NULL OR is_del = 0)
+      AND TRIM(COALESCE(name, '')) <> ''
+      AND TRIM(COALESCE(cmd, '')) <> ''
+    ORDER BY COALESCE(priority, 0) DESC, name COLLATE NOCASE ASC, cmd COLLATE NOCASE ASC
+    `, []);
+    return rows
+        .map((row) => ({
+        name: row.name?.trim() ?? '',
+        cmd: row.cmd?.trim() ?? '',
+    }))
+        .filter((row) => row.name.length > 0 && row.cmd.length > 0);
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerSyncCommand(program: Command): void;

package/dist/commands/sync.js

@@ -0,0 +1,68 @@
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import { DinoxError } from '../utils/errors.js';
+import { printYaml } from '../utils/output.js';
+import { connectPowerSync, getStatusSnapshot, waitForIdleDataFlow } from '../powersync/runtime.js';
+import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
+function parseSyncTimeoutMs(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+export function registerSyncCommand(program) {
+    program
+        .command('sync')
+        .description('Connect and synchronize local PowerSync database')
+        .action(async (_options, command) => {
+        const config = resolveConfig(await loadConfig());
+        const globals = command.optsWithGlobals?.() ?? {};
+        const jsonOutput = Boolean(globals.json);
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db, dbPath, stale } = await connectPowerSync({
+            config,
+            offline: false,
+            timeoutMs,
+        });
+        try {
+            const idle = await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+            const tokenIndex = await syncNoteTokenIndex(db);
+            const status = getStatusSnapshot(db);
+            const payload = {
+                ok: true,
+                dbPath,
+                stale,
+                idle,
+                uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
+                tokenIndex,
+                status,
+            };
+            if (jsonOutput) {
+                printYaml(payload);
+            }
+            else {
+                console.log(`db: ${payload.dbPath}`);
+                if (!payload.uploadEnabled) {
+                    console.log('warning: upload disabled (powersync.uploadBaseUrl is unset)');
+                }
+                if (payload.status.lastSyncedAt) {
+                    console.log(`lastSyncedAt: ${payload.status.lastSyncedAt}`);
+                }
+                if (payload.stale) {
+                    console.log('warning: sync timed out; local cache may be stale');
+                }
+                if (!payload.idle) {
+                    console.log('warning: data flow did not become idle before timeout');
+                }
+                console.log(`tokenIndex: scanned=${payload.tokenIndex.scanned} reindexed=${payload.tokenIndex.reindexed} skipped=${payload.tokenIndex.skipped} removed=${payload.tokenIndex.removed} ftsRowsUpserted=${payload.tokenIndex.ftsRowsUpserted}`);
+            }
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+}

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerTagsCommand(program: Command): void;

package/dist/commands/tags/index.js

@@ -0,0 +1,120 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { DinoxError } from '../../utils/errors.js';
+import { printYaml } from '../../utils/output.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { addTag, listTags } from './repo.js';
+function parseSyncTimeoutMs(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+async function syncBeforeTagCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+    await syncNoteTokenIndex(db);
+}
+async function runTagListCommand(options, command) {
+    const globals = command.optsWithGlobals?.() ?? {};
+    const offline = Boolean(options.offline ?? globals.offline);
+    const jsonOutput = Boolean(options.json ?? globals.json);
+    const config = resolveConfig(await loadConfig());
+    const timeoutMs = parseSyncTimeoutMs(options.syncTimeout ?? globals.syncTimeout) ?? config.sync.timeoutMs;
+    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+    try {
+        await syncBeforeTagCommand(db, offline, timeoutMs);
+        const tags = await listTags(db);
+        if (jsonOutput) {
+            printYaml({ stale, count: tags.length, tags });
+            return;
+        }
+        if (stale && !offline) {
+            console.log('warning: sync timed out; results may be stale');
+        }
+        if (tags.length === 0) {
+            console.log('No tags.');
+            return;
+        }
+        for (const tag of tags) {
+            console.log(tag);
+        }
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+export function registerTagsCommand(program) {
+    const tag = program.command('tag').description('Manage tags');
+    tag
+        .command('list')
+        .description('List tags from c_tag_node')
+        .option('--json', 'output machine-readable YAML')
+        .option('--offline', 'skip connect/sync and only use local cache')
+        .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
+        .action(runTagListCommand);
+    tag
+        .command('add')
+        .description('Create a new tag in c_tag_node')
+        .argument('[name]', 'tag name/path (supports slash hierarchy)')
+        .option('--name <string>', 'tag name/path (alternative to positional name)')
+        .option('--emoji <string>', 'tag emoji')
+        .option('--json', 'output machine-readable YAML')
+        .option('--offline', 'skip connect/sync and only use local cache')
+        .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
+        .action(async (nameArg, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(options.offline ?? globals.offline);
+        const jsonOutput = Boolean(options.json ?? globals.json);
+        const optionName = typeof options.name === 'string' ? options.name : undefined;
+        const name = (nameArg ?? optionName ?? '').trim();
+        if (!name) {
+            throw new DinoxError('Tag name is required. Use `dino tag add <name>` or `dino tag add --name <name>`.');
+        }
+        if (nameArg && optionName && nameArg.trim() !== optionName.trim()) {
+            throw new DinoxError('Conflicting tag name values from positional argument and --name option.');
+        }
+        const rawConfig = await loadConfig();
+        const config = resolveConfig(rawConfig);
+        const timeoutMs = parseSyncTimeoutMs(options.syncTimeout ?? globals.syncTimeout) ?? config.sync.timeoutMs;
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeTagCommand(db, offline, timeoutMs);
+            const result = await addTag(db, {
+                name,
+                userId: identity.userId,
+                emoji: typeof options.emoji === 'string' ? options.emoji : undefined,
+            });
+            if (!offline && !config.powersync.uploadBaseUrl) {
+                console.log('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
+            }
+            if (!offline) {
+                await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
+            }
+            const payload = { ok: true, stale: offline ? true : stale, ...result };
+            if (jsonOutput) {
+                printYaml(payload);
+                return;
+            }
+            console.log(result.id);
+            if (stale && !offline) {
+                console.log('warning: sync timed out; results may be stale');
+            }
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    tag.action((_options, command) => {
+        command.outputHelp();
+    });
+}

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

@@ -0,0 +1,14 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export type AddTagInput = {
+    name: string;
+    userId: string;
+    emoji?: string;
+};
+export type AddTagResult = {
+    id: string;
+    tag: string;
+    createdNodes: number;
+    restoredNodes: number;
+};
+export declare function listTags(db: AbstractPowerSyncDatabase): Promise<string[]>;
+export declare function addTag(db: AbstractPowerSyncDatabase, input: AddTagInput): Promise<AddTagResult>;

package/dist/commands/tags/repo.js

@@ -0,0 +1,247 @@
+import { generateId } from '../../utils/id.js';
+import { DinoxError } from '../../utils/errors.js';
+function canonicalizeTagPath(value) {
+    return value
+        .split(/[\\/]+/g)
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .join('/');
+}
+async function getTagNodeColumns(db) {
+    const rows = await db.getAll('PRAGMA table_info(c_tag_node)', []);
+    return new Set(rows.map((row) => row.name).filter(Boolean));
+}
+async function loadTagNodes(db, columnNames) {
+    const fullPathExpr = columnNames.has('full_path')
+        ? (columnNames.has('path_key')
+            ? `TRIM(COALESCE(full_path, path_key, ''))`
+            : `TRIM(COALESCE(full_path, ''))`)
+        : `TRIM(COALESCE(path_key, ''))`;
+    const pathKeyExpr = columnNames.has('path_key')
+        ? (columnNames.has('full_path')
+            ? `TRIM(COALESCE(path_key, full_path, ''))`
+            : `TRIM(COALESCE(path_key, ''))`)
+        : `TRIM(COALESCE(full_path, ''))`;
+    const userIdExpr = columnNames.has('user_id')
+        ? `TRIM(COALESCE(user_id, ''))`
+        : `''`;
+    const emojiExpr = columnNames.has('emoji')
+        ? `TRIM(COALESCE(emoji, ''))`
+        : `''`;
+    const parentIdExpr = columnNames.has('parent_id') ? 'parent_id' : 'NULL';
+    const depthExpr = columnNames.has('depth') ? 'depth' : 'NULL';
+    const isActualExpr = columnNames.has('is_actual') ? 'is_actual' : 'NULL';
+    const isDelExpr = columnNames.has('is_del') ? 'is_del' : 'NULL';
+    const updatedOrderExpr = columnNames.has('updated_at') ? 'updated_at DESC,' : '';
+    const createdOrderExpr = columnNames.has('created_at') ? 'created_at DESC,' : '';
+    const rows = await db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      ${fullPathExpr} AS full_path,
+      ${pathKeyExpr} AS path_key,
+      ${parentIdExpr} AS parent_id,
+      ${depthExpr} AS depth,
+      ${isActualExpr} AS is_actual,
+      ${isDelExpr} AS is_del,
+      ${userIdExpr} AS user_id,
+      ${emojiExpr} AS emoji
+    FROM c_tag_node
+    WHERE ${fullPathExpr} <> ''
+    ORDER BY
+      CASE WHEN is_del IS NULL OR is_del = 0 THEN 0 ELSE 1 END ASC,
+      CASE WHEN is_actual IS NULL THEN 0 ELSE is_actual END DESC,
+      ${updatedOrderExpr}
+      ${createdOrderExpr}
+      id DESC
+    `, []);
+    const nodes = new Map();
+    for (const row of rows) {
+        const id = row.id?.trim() ?? '';
+        if (!id) {
+            continue;
+        }
+        const fullPath = canonicalizeTagPath(row.full_path ?? row.path_key ?? '');
+        if (!fullPath) {
+            continue;
+        }
+        if (nodes.has(fullPath)) {
+            continue;
+        }
+        nodes.set(fullPath, {
+            id,
+            fullPath,
+            pathKey: canonicalizeTagPath(row.path_key ?? fullPath) || fullPath,
+            parentId: row.parent_id ?? null,
+            depth: typeof row.depth === 'number' ? row.depth : null,
+            isActual: typeof row.is_actual === 'number' ? row.is_actual : null,
+            isDel: typeof row.is_del === 'number' ? row.is_del : null,
+            userId: row.user_id?.trim() ?? '',
+            emoji: row.emoji?.trim() ?? '',
+        });
+    }
+    return nodes;
+}
+export async function listTags(db) {
+    const rows = await db.getAll(`
+    SELECT DISTINCT TRIM(COALESCE(full_path, path_key, '')) AS tag
+    FROM c_tag_node
+    WHERE (is_del IS NULL OR is_del = 0)
+      AND (is_actual IS NULL OR is_actual != 0)
+      AND TRIM(COALESCE(full_path, path_key, '')) <> ''
+    ORDER BY tag COLLATE NOCASE ASC
+    `, []);
+    return rows.map((row) => row.tag?.trim() ?? '').filter(Boolean);
+}
+export async function addTag(db, input) {
+    const userId = input.userId.trim();
+    const emoji = typeof input.emoji === 'string' ? input.emoji.trim() : '';
+    const tag = canonicalizeTagPath(input.name);
+    if (!tag) {
+        throw new DinoxError('Tag name is required');
+    }
+    const columnNames = await getTagNodeColumns(db);
+    if (!columnNames.has('id')) {
+        throw new DinoxError('c_tag_node table is missing required column: id');
+    }
+    if (!columnNames.has('full_path') && !columnNames.has('path_key')) {
+        throw new DinoxError('c_tag_node table is missing required column: full_path or path_key');
+    }
+    const requiredUserColumns = ['user_id'].filter((column) => columnNames.has(column));
+    if (requiredUserColumns.length > 0 && !userId) {
+        throw new DinoxError(`c_tag_node insert requires ${requiredUserColumns.join(', ')}. Missing persisted userId. Run \`dino auth login\` first.`);
+    }
+    const nodesByPath = await loadTagNodes(db, columnNames);
+    const existingLeaf = nodesByPath.get(tag);
+    if (existingLeaf && existingLeaf.isDel !== 1 && existingLeaf.isActual === 1) {
+        throw new DinoxError(`Tag already exists: ${tag}`, {
+            details: {
+                type: 'tag_exists',
+                tag,
+                id: existingLeaf.id,
+                question: 'This tag already exists. Do you want to keep using the existing tag?',
+            },
+        });
+    }
+    const timestamp = new Date().toISOString();
+    const segments = tag.split('/');
+    let createdNodes = 0;
+    let restoredNodes = 0;
+    let parentId = null;
+    let leafId = '';
+    for (let i = 0; i < segments.length; i += 1) {
+        const path = segments.slice(0, i + 1).join('/');
+        const isLeaf = i === segments.length - 1;
+        const existing = nodesByPath.get(path);
+        if (existing) {
+            const assignments = [];
+            const params = [];
+            const setValue = (column, value) => {
+                if (!columnNames.has(column)) {
+                    return;
+                }
+                assignments.push(`${column} = ?`);
+                params.push(value);
+            };
+            if (existing.isDel === 1) {
+                setValue('is_del', 0);
+            }
+            if (isLeaf && existing.isActual !== 1) {
+                setValue('is_actual', 1);
+            }
+            if (columnNames.has('updated_at')) {
+                setValue('updated_at', timestamp);
+            }
+            if (columnNames.has('user_id') && !existing.userId) {
+                setValue('user_id', userId);
+            }
+            if (columnNames.has('parent_id') && existing.parentId == null && parentId !== null) {
+                setValue('parent_id', parentId);
+            }
+            if (columnNames.has('depth') && existing.depth == null) {
+                setValue('depth', i);
+            }
+            if (columnNames.has('full_path') && existing.fullPath !== path) {
+                setValue('full_path', path);
+            }
+            if (columnNames.has('path_key') && existing.pathKey !== path) {
+                setValue('path_key', path);
+            }
+            if (isLeaf && emoji && columnNames.has('emoji') && existing.emoji !== emoji) {
+                setValue('emoji', emoji);
+            }
+            if (assignments.length > 0) {
+                params.push(existing.id);
+                await db.execute(`
+          UPDATE c_tag_node
+          SET ${assignments.join(', ')}
+          WHERE id = ?
+          `, params);
+                if (existing.isDel === 1) {
+                    restoredNodes += 1;
+                    existing.isDel = 0;
+                }
+                if (isLeaf && existing.isActual !== 1) {
+                    existing.isActual = 1;
+                }
+            }
+            parentId = existing.id;
+            if (isLeaf) {
+                leafId = existing.id;
+            }
+            continue;
+        }
+        const id = generateId();
+        const insertEntries = [];
+        const pushInsert = (column, value) => {
+            if (!columnNames.has(column)) {
+                return;
+            }
+            insertEntries.push([column, value]);
+        };
+        pushInsert('id', id);
+        pushInsert('user_id', userId);
+        pushInsert('emoji', isLeaf && emoji ? emoji : null);
+        pushInsert('full_path', path);
+        pushInsert('path_key', path);
+        pushInsert('parent_id', parentId);
+        pushInsert('depth', i);
+        pushInsert('is_actual', isLeaf ? 1 : 0);
+        pushInsert('is_del', 0);
+        pushInsert('created_at', timestamp);
+        pushInsert('updated_at', timestamp);
+        pushInsert('meta', '{}');
+        const insertColumns = insertEntries.map(([column]) => column);
+        const placeholders = insertColumns.map(() => '?').join(', ');
+        const insertParams = insertEntries.map(([, value]) => value);
+        await db.execute(`
+      INSERT INTO c_tag_node (${insertColumns.join(', ')})
+      VALUES (${placeholders})
+      `, insertParams);
+        const node = {
+            id,
+            fullPath: path,
+            pathKey: path,
+            parentId,
+            depth: i,
+            isActual: isLeaf ? 1 : 0,
+            isDel: 0,
+            userId,
+            emoji: isLeaf && emoji ? emoji : '',
+        };
+        nodesByPath.set(path, node);
+        createdNodes += 1;
+        parentId = id;
+        if (isLeaf) {
+            leafId = id;
+        }
+    }
+    if (!leafId) {
+        throw new DinoxError(`Failed to create tag: ${tag}`);
+    }
+    return {
+        id: leafId,
+        tag,
+        createdNodes,
+        restoredNodes,
+    };
+}

package/dist/config/keys.d.ts

@@ -0,0 +1,9 @@
+export declare const CONFIG_KEYS: readonly ["powersync.tokenEndpoint", "powersync.uploadV4Path", "powersync.uploadV2Path", "sync.timeoutMs"];
+export declare const FIXED_CONFIG_KEYS: readonly ["powersync.endpoint", "powersync.uploadBaseUrl"];
+export declare const READABLE_CONFIG_KEYS: readonly ["powersync.tokenEndpoint", "powersync.uploadV4Path", "powersync.uploadV2Path", "sync.timeoutMs", "powersync.endpoint", "powersync.uploadBaseUrl"];
+export type ConfigKey = (typeof CONFIG_KEYS)[number];
+export type FixedConfigKey = (typeof FIXED_CONFIG_KEYS)[number];
+export type ReadableConfigKey = (typeof READABLE_CONFIG_KEYS)[number];
+export declare function isConfigKey(value: string): value is ConfigKey;
+export declare function isFixedConfigKey(value: string): value is FixedConfigKey;
+export declare function isReadableConfigKey(value: string): value is ReadableConfigKey;

package/dist/config/keys.js

@@ -0,0 +1,17 @@
+export const CONFIG_KEYS = [
+    'powersync.tokenEndpoint',
+    'powersync.uploadV4Path',
+    'powersync.uploadV2Path',
+    'sync.timeoutMs',
+];
+export const FIXED_CONFIG_KEYS = ['powersync.endpoint', 'powersync.uploadBaseUrl'];
+export const READABLE_CONFIG_KEYS = [...CONFIG_KEYS, ...FIXED_CONFIG_KEYS];
+export function isConfigKey(value) {
+    return CONFIG_KEYS.includes(value);
+}
+export function isFixedConfigKey(value) {
+    return FIXED_CONFIG_KEYS.includes(value);
+}
+export function isReadableConfigKey(value) {
+    return READABLE_CONFIG_KEYS.includes(value);
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function getConfigDir(): string;
+export declare function getConfigFilePath(): string;
+export declare function getDataDir(): string;
+export declare function getPowerSyncDbPath(): string;