appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/cli/commands/importFileCommands.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseAdapter } from "appwrite-utils-helpers";
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare function importFileFromPath(adapter: DatabaseAdapter, filePath: string, databaseId: string, tableId: string): Promise<void>;
+export declare function importFilePromptMissing(adapter: DatabaseAdapter, database: any, filePath: string, targetDb?: string, targetTable?: string): Promise<void>;
+export declare const importFileCommands: {
+    importFile(cli: InteractiveCLI): Promise<void>;
+};

package/dist/cli/commands/importFileCommands.js

@@ -0,0 +1,674 @@
+import inquirer from "inquirer";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import Papa from "papaparse";
+import { ID, Query } from "node-appwrite";
+import pLimit from "p-limit";
+import { MessageFormatter, tryAwaitWithRetry, delay, } from "appwrite-utils-helpers";
+import { ProgressManager } from "../../shared/progressManager.js";
+import { fetchAllDatabases } from "../../databases/methods.js";
+const SYSTEM_FIELDS = new Set([
+    "$databaseId",
+    "$collectionId",
+    "$tableId",
+    "$sequence",
+    "$tenant",
+]);
+const PASSTHROUGH_FIELDS = new Set(["$id", "$permissions", "$createdAt", "$updatedAt"]);
+async function fetchSchema(adapter, databaseId, tableId) {
+    MessageFormatter.info(`Fetching schema for database="${databaseId}" table="${tableId}"`, { prefix: "Import" });
+    const tableInfo = await adapter.getTable({ databaseId, tableId });
+    const columns = tableInfo.data?.columns || tableInfo.data?.attributes || [];
+    const availableColumns = columns.filter((col) => !col.status || col.status === "available");
+    MessageFormatter.info(`Schema columns: ${availableColumns.map((c) => c.key || c.$id).join(", ")}`, { prefix: "Import" });
+    const columnTypeMap = new Map();
+    const enumElementsMap = new Map();
+    const arrayColumns = new Set();
+    const hasRelationships = availableColumns.some((col) => col.type === "relationship");
+    for (const col of availableColumns) {
+        const key = col.key || col.$id;
+        if (!key)
+            continue;
+        columnTypeMap.set(key, col.type);
+        if (col.array)
+            arrayColumns.add(key);
+        if (col.type === "enum" && Array.isArray(col.elements)) {
+            enumElementsMap.set(key, new Set(col.elements));
+        }
+    }
+    if (columnTypeMap.size > 0) {
+        MessageFormatter.info(`Table schema: ${columns.length} columns detected, will cast values to match types`, { prefix: "Import" });
+    }
+    return { columnTypeMap, arrayColumns, enumElementsMap, hasRelationships };
+}
+// ── Row cleaning ────────────────────────────────────────────────────────
+function cleanRow(row, schema) {
+    const { columnTypeMap, arrayColumns } = schema;
+    const clean = {};
+    for (const [key, value] of Object.entries(row)) {
+        if (SYSTEM_FIELDS.has(key))
+            continue;
+        if (PASSTHROUGH_FIELDS.has(key)) {
+            if (value === null || value === undefined || value === "null" || value === "undefined" || value === "")
+                continue;
+            if (key === "$permissions") {
+                if (Array.isArray(value)) {
+                    clean[key] = value;
+                }
+                else if (typeof value === "string" && value.trim()) {
+                    clean[key] = value.match(/[a-z]+\([^)]*\)/g) || [];
+                }
+            }
+            else if (key === "$createdAt" || key === "$updatedAt") {
+                const str = value instanceof Date ? value.toISOString() : String(value).trim();
+                // Only set if it looks like a valid ISO datetime
+                if (str && !isNaN(Date.parse(str))) {
+                    clean[key] = str;
+                }
+            }
+            else {
+                clean[key] = value;
+            }
+            continue;
+        }
+        if (columnTypeMap.size > 0 && !columnTypeMap.has(key))
+            continue;
+        if (value === null || value === undefined || value === "null")
+            continue;
+        const colType = columnTypeMap.get(key);
+        if (colType === "relationship")
+            continue;
+        // Array columns
+        if (arrayColumns.has(key)) {
+            let arr;
+            if (Array.isArray(value)) {
+                arr = value;
+            }
+            else if (typeof value === "string") {
+                const trimmed = value.trim();
+                if (!trimmed || trimmed === "[]") {
+                    clean[key] = [];
+                    continue;
+                }
+                if (trimmed.startsWith("[")) {
+                    try {
+                        arr = JSON.parse(trimmed);
+                    }
+                    catch {
+                        arr = trimmed.split(",").map((s) => s.trim()).filter(Boolean);
+                    }
+                }
+                else {
+                    arr = trimmed.split(",").map((s) => s.trim()).filter(Boolean);
+                }
+            }
+            else {
+                arr = [value];
+            }
+            // Cast elements to scalar type
+            if (colType === "integer") {
+                arr = arr.map((v) => typeof v === "number" ? Math.round(v) : parseInt(String(v), 10)).filter((v) => !isNaN(v));
+            }
+            else if (colType === "float" || colType === "double") {
+                arr = arr.map((v) => typeof v === "number" ? v : parseFloat(String(v))).filter((v) => !isNaN(v));
+            }
+            else if (colType === "boolean") {
+                arr = arr.map((v) => {
+                    if (typeof v === "boolean")
+                        return v;
+                    const s = String(v).toLowerCase().trim();
+                    return s === "true" || s === "1" || s === "yes";
+                });
+            }
+            else {
+                arr = arr.map((v) => String(v));
+            }
+            clean[key] = arr;
+            continue;
+        }
+        // Scalar casting
+        if (colType === "enum") {
+            clean[key] = String(value);
+        }
+        else if (colType === "boolean") {
+            if (typeof value === "boolean") {
+                clean[key] = value;
+            }
+            else if (typeof value === "string") {
+                const lower = value.toLowerCase().trim();
+                if (lower === "true" || lower === "1" || lower === "yes") {
+                    clean[key] = true;
+                }
+                else if (lower === "false" || lower === "0" || lower === "no" || lower === "") {
+                    clean[key] = false;
+                }
+                else {
+                    clean[key] = Boolean(value);
+                }
+            }
+            else if (typeof value === "number") {
+                clean[key] = value !== 0;
+            }
+            else {
+                clean[key] = Boolean(value);
+            }
+        }
+        else if (colType === "integer") {
+            if (typeof value === "number") {
+                clean[key] = Math.round(value);
+            }
+            else if (typeof value === "string" && value.trim() !== "") {
+                const parsed = parseInt(value, 10);
+                if (!isNaN(parsed))
+                    clean[key] = parsed;
+            }
+        }
+        else if (colType === "float" || colType === "double") {
+            if (typeof value === "number") {
+                clean[key] = value;
+            }
+            else if (typeof value === "string" && value.trim() !== "") {
+                const parsed = parseFloat(value);
+                if (!isNaN(parsed))
+                    clean[key] = parsed;
+            }
+        }
+        else if (typeof value === "string" && value === "") {
+            // Skip empty strings — let database use defaults
+            continue;
+        }
+        else {
+            clean[key] = value;
+        }
+    }
+    return clean;
+}
+// ── Upsert helpers ──────────────────────────────────────────────────────
+function makeUpsertRow(adapter, databaseId, tableId) {
+    return async (row) => {
+        const { $id, $permissions, ...data } = row;
+        const rowId = $id || ID.unique();
+        const permissions = Array.isArray($permissions) ? $permissions : undefined;
+        try {
+            await adapter.createRow({ databaseId, tableId, id: rowId, data, permissions });
+        }
+        catch (error) {
+            const code = error?.originalError?.code || error?.code;
+            if (code === 409) {
+                await adapter.updateRow({ databaseId, tableId, id: rowId, data, permissions });
+            }
+            else {
+                throw error;
+            }
+        }
+    };
+}
+// Track the max working bulk size across calls so we don't retry sizes that already failed
+let effectiveBulkMax = 2500;
+async function flushBatch(batch, adapter, databaseId, tableId, schema, useBulk, upsertRow) {
+    let created = 0;
+    let errors = 0;
+    let firstError = null;
+    if (useBulk) {
+        // Deduplicate by $id within the batch — keep last occurrence
+        const deduped = new Map();
+        for (const row of batch) {
+            const id = row.$id || ID.unique();
+            if (!row.$id)
+                row.$id = id;
+            deduped.set(id, row);
+        }
+        const dedupedRows = Array.from(deduped.values());
+        // Split into sub-batches of effectiveBulkMax and run up to 5 concurrently
+        const subBatches = [];
+        for (let i = 0; i < dedupedRows.length; i += effectiveBulkMax) {
+            subBatches.push(dedupedRows.slice(i, i + effectiveBulkMax));
+        }
+        const bulkLimit = pLimit(500);
+        const results = await Promise.all(subBatches.map((sub) => bulkLimit(async () => {
+            try {
+                const result = await tryAwaitWithRetry(async () => adapter.bulkUpsertRows({ databaseId, tableId, rows: sub }));
+                return { created: result?.total || result?.rows?.length || sub.length, errors: 0, firstError: null };
+            }
+            catch (error) {
+                const msg = error?.message || error?.originalError?.message || String(error);
+                const isSizeError = /too many|payload too large|batch.*size|limit|no longer than \d+ items|array.*\d+ items/i.test(msg)
+                    || error?.originalError?.code === 413
+                    || error?.code === 413
+                    || error?.originalError?.type === "general_argument_invalid";
+                if (isSizeError && sub.length > 50) {
+                    const newMax = Math.floor(sub.length / 2);
+                    if (newMax < effectiveBulkMax) {
+                        effectiveBulkMax = newMax;
+                        MessageFormatter.warning(`Bulk batch too large, reducing to ${effectiveBulkMax} per call`, { prefix: "Import" });
+                    }
+                    // Retry halved sequentially within this slot
+                    const mid = Math.ceil(sub.length / 2);
+                    const halves = [sub.slice(0, mid), sub.slice(mid)];
+                    let hCreated = 0, hErrors = 0;
+                    let hFirst = null;
+                    for (const half of halves) {
+                        try {
+                            const r = await tryAwaitWithRetry(async () => adapter.bulkUpsertRows({ databaseId, tableId, rows: half }));
+                            hCreated += r?.total || r?.rows?.length || half.length;
+                        }
+                        catch (e) {
+                            hErrors += half.length;
+                            if (!hFirst)
+                                hFirst = e?.message || String(e);
+                        }
+                    }
+                    return { created: hCreated, errors: hErrors, firstError: hFirst };
+                }
+                return { created: 0, errors: sub.length, firstError: msg };
+            }
+        })));
+        for (const r of results) {
+            created += r.created;
+            errors += r.errors;
+            if (r.firstError && !firstError)
+                firstError = r.firstError;
+        }
+    }
+    else {
+        const limit = pLimit(500);
+        const promises = batch.map((row) => limit(async () => {
+            try {
+                await upsertRow(row);
+                created++;
+            }
+            catch (error) {
+                errors++;
+                const msg = error?.message || error?.originalError?.message || String(error);
+                if (!firstError)
+                    firstError = msg;
+            }
+        }));
+        await Promise.all(promises);
+    }
+    return { created, errors, firstError };
+}
+// ── Streaming CSV/TSV importer ──────────────────────────────────────────
+async function countLines(filePath) {
+    return new Promise((resolve, reject) => {
+        let count = 0;
+        const stream = fs.createReadStream(filePath, { highWaterMark: 64 * 1024 });
+        stream.on("data", (chunk) => {
+            const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            for (let i = 0; i < buf.length; i++) {
+                if (buf[i] === 0x0a)
+                    count++;
+            }
+        });
+        stream.on("end", () => resolve(count)); // header line means count ≈ data rows
+        stream.on("error", reject);
+    });
+}
+async function importCsvStream(adapter, filePath, databaseId, tableId, schema, delimiter) {
+    const useBulk = false; // individual upserts with high concurrency
+    const BATCH_SIZE = 500;
+    const upsertRow = makeUpsertRow(adapter, databaseId, tableId);
+    if (schema.hasRelationships) {
+        MessageFormatter.info("Table has relationships — using individual upserts (25 concurrent)", { prefix: "Import" });
+    }
+    if (useBulk) {
+        MessageFormatter.info("Using bulk upsert", { prefix: "Import" });
+    }
+    // Get approximate row count for progress
+    const lineCount = await countLines(filePath);
+    MessageFormatter.info(`~${lineCount} rows detected (streaming)`, { prefix: "Import" });
+    const progress = ProgressManager.create(`import-${tableId}`, lineCount, {
+        title: `Importing into ${tableId}`,
+    });
+    let totalCreated = 0;
+    let totalErrors = 0;
+    let firstError = null;
+    let buffer = [];
+    let headerLogged = false;
+    await new Promise((resolve, reject) => {
+        const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+        Papa.parse(stream, {
+            header: true,
+            dynamicTyping: false,
+            skipEmptyLines: true,
+            delimiter,
+            step: async (result, parser) => {
+                if (result.errors?.length > 0) {
+                    const critical = result.errors.filter((e) => e.type !== "FieldMismatch");
+                    if (critical.length > 0 && !firstError) {
+                        firstError = critical[0].message;
+                    }
+                }
+                const cleaned = cleanRow(result.data, schema);
+                if (!headerLogged && cleaned) {
+                    MessageFormatter.info(`Columns: ${Object.keys(cleaned).join(", ")}`, { prefix: "Import" });
+                    headerLogged = true;
+                }
+                buffer.push(cleaned);
+                if (buffer.length >= BATCH_SIZE) {
+                    parser.pause();
+                    const batch = buffer.splice(0, buffer.length);
+                    const stats = await flushBatch(batch, adapter, databaseId, tableId, schema, useBulk, upsertRow);
+                    totalCreated += stats.created;
+                    totalErrors += stats.errors;
+                    if (stats.firstError && !firstError)
+                        firstError = stats.firstError;
+                    progress.update(totalCreated + totalErrors);
+                    parser.resume();
+                }
+            },
+            complete: async () => {
+                // Flush remaining rows
+                if (buffer.length > 0) {
+                    const stats = await flushBatch(buffer, adapter, databaseId, tableId, schema, useBulk, upsertRow);
+                    totalCreated += stats.created;
+                    totalErrors += stats.errors;
+                    if (stats.firstError && !firstError)
+                        firstError = stats.firstError;
+                }
+                resolve();
+            },
+            error: (error) => {
+                reject(error);
+            },
+        });
+    });
+    progress.setTotal(totalCreated + totalErrors);
+    progress.stop();
+    if (firstError) {
+        MessageFormatter.error(`Sample error: ${firstError}`, undefined, { prefix: "Import" });
+    }
+    if (totalErrors > 0) {
+        MessageFormatter.warning(`Imported ${totalCreated} rows with ${totalErrors} errors into ${tableId}`, { prefix: "Import" });
+    }
+    else {
+        MessageFormatter.success(`Successfully imported ${totalCreated} rows into ${tableId}`, { prefix: "Import" });
+    }
+}
+// ── Streaming JSONL importer ────────────────────────────────────────────
+async function importJsonlStream(adapter, filePath, databaseId, tableId, schema) {
+    const useBulk = false; // individual upserts with high concurrency
+    const BATCH_SIZE = 500;
+    const upsertRow = makeUpsertRow(adapter, databaseId, tableId);
+    if (useBulk)
+        MessageFormatter.info("Using bulk upsert", { prefix: "Import" });
+    const lineCount = await countLines(filePath);
+    MessageFormatter.info(`~${lineCount} rows detected (streaming)`, { prefix: "Import" });
+    const progress = ProgressManager.create(`import-${tableId}`, lineCount, {
+        title: `Importing into ${tableId}`,
+    });
+    let totalCreated = 0;
+    let totalErrors = 0;
+    let firstError = null;
+    let buffer = [];
+    let headerLogged = false;
+    const rl = readline.createInterface({
+        input: fs.createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let row;
+        try {
+            row = JSON.parse(trimmed);
+        }
+        catch {
+            totalErrors++;
+            if (!firstError)
+                firstError = `Invalid JSON line: ${trimmed.slice(0, 80)}`;
+            continue;
+        }
+        const cleaned = cleanRow(row, schema);
+        if (!headerLogged && cleaned) {
+            MessageFormatter.info(`Columns: ${Object.keys(cleaned).join(", ")}`, { prefix: "Import" });
+            headerLogged = true;
+        }
+        buffer.push(cleaned);
+        if (buffer.length >= BATCH_SIZE) {
+            const batch = buffer.splice(0, buffer.length);
+            const stats = await flushBatch(batch, adapter, databaseId, tableId, schema, useBulk, upsertRow);
+            totalCreated += stats.created;
+            totalErrors += stats.errors;
+            if (stats.firstError && !firstError)
+                firstError = stats.firstError;
+            progress.update(totalCreated + totalErrors);
+        }
+    }
+    // Flush remaining
+    if (buffer.length > 0) {
+        const stats = await flushBatch(buffer, adapter, databaseId, tableId, schema, useBulk, upsertRow);
+        totalCreated += stats.created;
+        totalErrors += stats.errors;
+        if (stats.firstError && !firstError)
+            firstError = stats.firstError;
+    }
+    progress.setTotal(totalCreated + totalErrors);
+    progress.stop();
+    if (firstError) {
+        MessageFormatter.error(`Sample error: ${firstError}`, undefined, { prefix: "Import" });
+    }
+    if (totalErrors > 0) {
+        MessageFormatter.warning(`Imported ${totalCreated} rows with ${totalErrors} errors into ${tableId}`, { prefix: "Import" });
+    }
+    else {
+        MessageFormatter.success(`Successfully imported ${totalCreated} rows into ${tableId}`, { prefix: "Import" });
+    }
+}
+// ── JSON importer (non-streaming, for .json files) ──────────────────────
+async function importJsonFile(adapter, filePath, databaseId, tableId, schema) {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    let rows;
+    if (Array.isArray(parsed)) {
+        rows = parsed;
+    }
+    else if (typeof parsed === "object" && parsed !== null) {
+        const arrayKey = Object.keys(parsed).find((k) => Array.isArray(parsed[k]));
+        if (arrayKey) {
+            MessageFormatter.info(`Using "${arrayKey}" array from JSON (${parsed[arrayKey].length} items)`, { prefix: "Import" });
+            rows = parsed[arrayKey];
+        }
+        else {
+            throw new Error("JSON file must be an array or an object containing an array");
+        }
+    }
+    else {
+        throw new Error("JSON file must be an array or an object containing an array");
+    }
+    if (!rows.length) {
+        MessageFormatter.warning("No rows found in file", { prefix: "Import" });
+        return;
+    }
+    MessageFormatter.info(`Parsed ${rows.length} rows`, { prefix: "Import" });
+    const useBulk = false; // individual upserts with high concurrency
+    const BATCH_SIZE = 500;
+    const upsertRow = makeUpsertRow(adapter, databaseId, tableId);
+    if (useBulk)
+        MessageFormatter.info("Using bulk upsert", { prefix: "Import" });
+    if (schema.hasRelationships) {
+        MessageFormatter.info("Table has relationships — using individual upserts (25 concurrent)", { prefix: "Import" });
+    }
+    const cleanedRows = rows.map((row) => cleanRow(row, schema));
+    MessageFormatter.info(`Columns: ${Object.keys(cleanedRows[0]).join(", ")}`, { prefix: "Import" });
+    const progress = ProgressManager.create(`import-${tableId}`, cleanedRows.length, {
+        title: `Importing into ${tableId}`,
+    });
+    let totalCreated = 0;
+    let totalErrors = 0;
+    let firstError = null;
+    // Process in batches
+    for (let i = 0; i < cleanedRows.length; i += BATCH_SIZE) {
+        const batch = cleanedRows.slice(i, i + BATCH_SIZE);
+        const stats = await flushBatch(batch, adapter, databaseId, tableId, schema, useBulk, upsertRow);
+        totalCreated += stats.created;
+        totalErrors += stats.errors;
+        if (stats.firstError && !firstError)
+            firstError = stats.firstError;
+        progress.update(totalCreated + totalErrors);
+    }
+    progress.setTotal(totalCreated + totalErrors);
+    progress.stop();
+    if (firstError) {
+        MessageFormatter.error(`Sample error: ${firstError}`, undefined, { prefix: "Import" });
+    }
+    if (totalErrors > 0) {
+        MessageFormatter.warning(`Imported ${totalCreated} rows with ${totalErrors} errors into ${tableId}`, { prefix: "Import" });
+    }
+    else {
+        MessageFormatter.success(`Successfully imported ${totalCreated} rows into ${tableId}`, { prefix: "Import" });
+    }
+}
+// ── Main entry point ────────────────────────────────────────────────────
+export async function importFileFromPath(adapter, filePath, databaseId, tableId) {
+    const resolvedPath = path.resolve(filePath);
+    if (!fs.existsSync(resolvedPath)) {
+        MessageFormatter.error(`File not found: ${resolvedPath}`, undefined, {
+            prefix: "Import",
+        });
+        return;
+    }
+    const ext = path.extname(resolvedPath).toLowerCase();
+    const supported = new Set([".csv", ".tsv", ".json", ".jsonl"]);
+    if (!supported.has(ext)) {
+        MessageFormatter.error(`Unsupported file format: ${ext}. Use .csv, .tsv, .json, or .jsonl`, undefined, { prefix: "Import" });
+        return;
+    }
+    const stat = fs.statSync(resolvedPath);
+    const sizeMB = (stat.size / 1024 / 1024).toFixed(1);
+    MessageFormatter.info(`Importing ${path.basename(resolvedPath)} (${sizeMB} MB)`, { prefix: "Import" });
+    const schema = await fetchSchema(adapter, databaseId, tableId);
+    try {
+        if (ext === ".csv" || ext === ".tsv") {
+            await importCsvStream(adapter, resolvedPath, databaseId, tableId, schema, ext === ".tsv" ? "\t" : undefined);
+        }
+        else if (ext === ".jsonl") {
+            await importJsonlStream(adapter, resolvedPath, databaseId, tableId, schema);
+        }
+        else {
+            await importJsonFile(adapter, resolvedPath, databaseId, tableId, schema);
+        }
+    }
+    catch (error) {
+        MessageFormatter.error(`Failed to import file: ${error.message}`, error, { prefix: "Import" });
+    }
+}
+// ── Prompt for missing targetDb / targetTable ───────────────────────────
+export async function importFilePromptMissing(adapter, database, filePath, targetDb, targetTable) {
+    let databaseId = targetDb;
+    let tableId = targetTable;
+    if (!databaseId) {
+        const allDatabases = await fetchAllDatabases(database);
+        if (allDatabases.length === 0) {
+            MessageFormatter.error("No databases found", undefined, { prefix: "Import" });
+            return;
+        }
+        const { selectedDb } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedDb",
+                message: "Select target database:",
+                choices: allDatabases.map((db) => ({
+                    name: `${db.name} (${db.$id})`,
+                    value: db.$id,
+                })),
+            },
+        ]);
+        databaseId = selectedDb;
+    }
+    if (!tableId) {
+        const tablesResponse = await adapter.listTables({
+            databaseId: databaseId,
+            queries: [Query.limit(500)],
+        });
+        const tables = tablesResponse.tables || tablesResponse.data || [];
+        if (tables.length === 0) {
+            MessageFormatter.error("No tables found in selected database", undefined, { prefix: "Import" });
+            return;
+        }
+        const { selectedTable } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedTable",
+                message: "Select target table:",
+                choices: tables.map((t) => ({
+                    name: `${t.name} (${t.$id})`,
+                    value: t.$id,
+                })),
+            },
+        ]);
+        tableId = selectedTable;
+    }
+    await importFileFromPath(adapter, filePath, databaseId, tableId);
+}
+// ── Interactive wrapper ─────────────────────────────────────────────────
+export const importFileCommands = {
+    async importFile(cli) {
+        const controller = cli.controller;
+        const adapter = controller.adapter;
+        const database = controller.database;
+        // 1. Prompt for file path
+        const { filePath } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "filePath",
+                message: "Path to CSV or JSON file:",
+                validate: (input) => {
+                    if (!input || !input.trim())
+                        return "Please provide a file path";
+                    const resolved = path.resolve(input.trim());
+                    if (!fs.existsSync(resolved))
+                        return `File not found: ${resolved}`;
+                    const ext = path.extname(resolved).toLowerCase();
+                    if (![".csv", ".tsv", ".json", ".jsonl"].includes(ext))
+                        return "Supported formats: .csv, .tsv, .json, .jsonl";
+                    return true;
+                },
+            },
+        ]);
+        // 2. Select database
+        const allDatabases = await fetchAllDatabases(database);
+        if (allDatabases.length === 0) {
+            MessageFormatter.error("No databases found", undefined, {
+                prefix: "Import",
+            });
+            return;
+        }
+        const { selectedDb } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedDb",
+                message: "Select target database:",
+                choices: allDatabases.map((db) => ({
+                    name: `${db.name} (${db.$id})`,
+                    value: db.$id,
+                })),
+            },
+        ]);
+        // 3. Select table
+        const tablesResponse = await adapter.listTables({
+            databaseId: selectedDb,
+            queries: [Query.limit(500)],
+        });
+        const tables = tablesResponse.tables || tablesResponse.data || [];
+        if (tables.length === 0) {
+            MessageFormatter.error("No tables found in selected database", undefined, { prefix: "Import" });
+            return;
+        }
+        const { selectedTable } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedTable",
+                message: "Select target table:",
+                choices: tables.map((t) => ({
+                    name: `${t.name} (${t.$id})`,
+                    value: t.$id,
+                })),
+            },
+        ]);
+        // 4. Import
+        await importFileFromPath(adapter, filePath.trim(), selectedDb, selectedTable);
+    },
+};