gufi-cli 0.1.3 → 0.1.4

package/CLAUDE.md

@@ -1419,6 +1419,36 @@ gufi automation calcular_stock -c 116 --edit
 gufi automation calcular_stock -c 116 --file script.js
 ```
 
+### Row CRUD (Datos de Tablas)
+
+```bash
+# Listar registros de una tabla
+gufi rows m360_t16192                    # Últimos 20 registros
+gufi rows m360_t16192 -l 50              # Últimos 50 registros
+gufi rows m360_t16192 -f estado=activo   # Filtrar por campo
+
+# Ver un registro específico
+gufi row m360_t16192 123
+
+# Crear registro
+gufi row:create m360_t16192 --data '{"nombre":"Test","estado":"activo"}'
+gufi row:create m360_t16192 --file nuevo.json
+
+# Actualizar registro
+gufi row:update m360_t16192 123 --data '{"estado":"completado"}'
+gufi row:update m360_t16192 123 --file cambios.json
+
+# Eliminar registro
+gufi row:delete m360_t16192 123
+
+# Duplicar registro (copia sin id/timestamps)
+gufi row:duplicate m360_t16192 123
+
+# Crear múltiples registros desde archivo JSON
+gufi rows:create m360_t16192 --file datos.json
+# datos.json debe ser un array: [{"nombre":"A"},{"nombre":"B"}]
+```
+
 ### Desarrollo de Views
 
 ```bash

package/dist/commands/rows.d.ts

@@ -0,0 +1,46 @@
+/**
+ * gufi rows - CRUD operations on table rows
+ * For quick testing and data manipulation
+ */
+interface RowsOptions {
+    company?: string;
+    limit?: string;
+    offset?: string;
+    sort?: string;
+    order?: string;
+    filter?: string;
+}
+interface RowOptions {
+    company?: string;
+    data?: string;
+    file?: string;
+}
+/**
+ * gufi rows <table> - List rows from a table
+ */
+export declare function rowsListCommand(table: string, options: RowsOptions): Promise<void>;
+/**
+ * gufi row <table> <id> - Get a single row
+ */
+export declare function rowGetCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:create <table> --data '{...}' - Create a row
+ */
+export declare function rowCreateCommand(table: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:update <table> <id> --data '{...}' - Update a row
+ */
+export declare function rowUpdateCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:delete <table> <id> - Delete a row
+ */
+export declare function rowDeleteCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:duplicate <table> <id> - Duplicate a row
+ */
+export declare function rowDuplicateCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi rows:create <table> --file datos.json - Bulk create rows
+ */
+export declare function rowsBulkCreateCommand(table: string, options: RowOptions): Promise<void>;
+export {};

package/dist/commands/rows.js

@@ -0,0 +1,243 @@
+/**
+ * gufi rows - CRUD operations on table rows
+ * For quick testing and data manipulation
+ */
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import { getToken, getApiUrl } from "../lib/config.js";
+async function apiRequest(endpoint, options = {}) {
+    const token = getToken();
+    if (!token) {
+        throw new Error("No estás logueado. Ejecuta: gufi login");
+    }
+    const url = `${getApiUrl()}${endpoint}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+            "X-Client": "cli",
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API Error ${response.status}: ${text}`);
+    }
+    return response.json();
+}
+/**
+ * gufi rows <table> - List rows from a table
+ */
+export async function rowsListCommand(table, options) {
+    const spinner = ora("Cargando registros...").start();
+    try {
+        const limit = options.limit || "20";
+        const offset = options.offset || "0";
+        const sort = options.sort || "id";
+        const order = options.order || "DESC";
+        let endpoint = `/api/tables/${table}?_start=${offset}&_end=${parseInt(offset) + parseInt(limit)}&_sort=${sort}&_order=${order}`;
+        if (options.filter) {
+            // Parse filter like "estado=pendiente"
+            const [field, value] = options.filter.split("=");
+            if (field && value) {
+                endpoint += `&${field}=${encodeURIComponent(value)}`;
+            }
+        }
+        const data = await apiRequest(endpoint);
+        spinner.stop();
+        console.log(chalk.magenta(`\n  📋 ${table}\n`));
+        if (!data || data.length === 0) {
+            console.log(chalk.gray("  No hay registros\n"));
+            return;
+        }
+        // Show as table
+        const rows = Array.isArray(data) ? data : [data];
+        // Get columns from first row
+        const columns = Object.keys(rows[0]).slice(0, 6); // Max 6 columns
+        // Header
+        console.log(chalk.gray("  " + columns.map((c) => c.padEnd(15)).join(" ")));
+        console.log(chalk.gray("  " + "─".repeat(columns.length * 16)));
+        // Rows
+        for (const row of rows) {
+            const values = columns.map((col) => {
+                let val = row[col];
+                if (val === null || val === undefined)
+                    val = "-";
+                if (typeof val === "object")
+                    val = JSON.stringify(val).slice(0, 12);
+                return String(val).slice(0, 14).padEnd(15);
+            });
+            console.log("  " + values.join(" "));
+        }
+        console.log(chalk.gray(`\n  Total: ${rows.length} registros\n`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row <table> <id> - Get a single row
+ */
+export async function rowGetCommand(table, id, options) {
+    const spinner = ora("Cargando registro...").start();
+    try {
+        const data = await apiRequest(`/api/tables/${table}/${id}`);
+        spinner.stop();
+        console.log(chalk.magenta(`\n  📄 ${table} #${id}\n`));
+        console.log(JSON.stringify(data, null, 2));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:create <table> --data '{...}' - Create a row
+ */
+export async function rowCreateCommand(table, options) {
+    const spinner = ora("Creando registro...").start();
+    try {
+        let data;
+        if (options.file) {
+            const content = fs.readFileSync(options.file, "utf-8");
+            data = JSON.parse(content);
+        }
+        else if (options.data) {
+            data = JSON.parse(options.data);
+        }
+        else {
+            spinner.fail(chalk.red("Usa --data '{...}' o --file datos.json"));
+            process.exit(1);
+        }
+        const result = await apiRequest(`/api/tables/${table}`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+        spinner.succeed(chalk.green(`Registro creado: ID ${result.id || result.data?.id}`));
+        console.log(chalk.gray(JSON.stringify(result.data || result, null, 2)));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:update <table> <id> --data '{...}' - Update a row
+ */
+export async function rowUpdateCommand(table, id, options) {
+    const spinner = ora("Actualizando registro...").start();
+    try {
+        let data;
+        if (options.file) {
+            const content = fs.readFileSync(options.file, "utf-8");
+            data = JSON.parse(content);
+        }
+        else if (options.data) {
+            data = JSON.parse(options.data);
+        }
+        else {
+            spinner.fail(chalk.red("Usa --data '{...}' o --file datos.json"));
+            process.exit(1);
+        }
+        const result = await apiRequest(`/api/tables/${table}/${id}`, {
+            method: "PUT",
+            body: JSON.stringify(data),
+        });
+        spinner.succeed(chalk.green(`Registro #${id} actualizado`));
+        console.log(chalk.gray(JSON.stringify(result.data || result, null, 2)));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:delete <table> <id> - Delete a row
+ */
+export async function rowDeleteCommand(table, id, options) {
+    const spinner = ora("Eliminando registro...").start();
+    try {
+        await apiRequest(`/api/tables/${table}/${id}`, {
+            method: "DELETE",
+        });
+        spinner.succeed(chalk.green(`Registro #${id} eliminado`));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:duplicate <table> <id> - Duplicate a row
+ */
+export async function rowDuplicateCommand(table, id, options) {
+    const spinner = ora("Duplicando registro...").start();
+    try {
+        // Get original row
+        const original = await apiRequest(`/api/tables/${table}/${id}`);
+        // Remove id and timestamps
+        const { id: _, created_at, updated_at, ...data } = original;
+        // Create new row
+        const result = await apiRequest(`/api/tables/${table}`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+        spinner.succeed(chalk.green(`Registro duplicado: #${id} → #${result.id || result.data?.id}`));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi rows:create <table> --file datos.json - Bulk create rows
+ */
+export async function rowsBulkCreateCommand(table, options) {
+    if (!options.file) {
+        console.log(chalk.red("\n  ✗ Usa --file datos.json\n"));
+        process.exit(1);
+    }
+    const spinner = ora("Creando registros...").start();
+    try {
+        const content = fs.readFileSync(options.file, "utf-8");
+        const rows = JSON.parse(content);
+        if (!Array.isArray(rows)) {
+            spinner.fail(chalk.red("El archivo debe contener un array de objetos"));
+            process.exit(1);
+        }
+        let created = 0;
+        let errors = 0;
+        for (const row of rows) {
+            try {
+                await apiRequest(`/api/tables/${table}`, {
+                    method: "POST",
+                    body: JSON.stringify(row),
+                });
+                created++;
+                spinner.text = `Creando registros... ${created}/${rows.length}`;
+            }
+            catch {
+                errors++;
+            }
+        }
+        if (errors === 0) {
+            spinner.succeed(chalk.green(`${created} registros creados`));
+        }
+        else {
+            spinner.warn(chalk.yellow(`${created} creados, ${errors} errores`));
+        }
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -20,5 +20,14 @@
  *   gufi company:create     Create a new company
  *   gufi automations        List automation scripts
  *   gufi automation <name>  View/edit automation code (--edit, --file)
+ *
+ * Row CRUD Commands:
+ *   gufi rows <table>           List rows from a table
+ *   gufi row <table> <id>       Get a single row
+ *   gufi row:create <table>     Create a new row (--data or --file)
+ *   gufi row:update <table> <id> Update a row (--data or --file)
+ *   gufi row:delete <table> <id> Delete a row
+ *   gufi row:duplicate <table> <id> Duplicate a row
+ *   gufi rows:create <table>    Bulk create from JSON file
  */
 export {};

package/dist/index.js

@@ -20,6 +20,15 @@
  *   gufi company:create     Create a new company
  *   gufi automations        List automation scripts
  *   gufi automation <name>  View/edit automation code (--edit, --file)
+ *
+ * Row CRUD Commands:
+ *   gufi rows <table>           List rows from a table
+ *   gufi row <table> <id>       Get a single row
+ *   gufi row:create <table>     Create a new row (--data or --file)
+ *   gufi row:update <table> <id> Update a row (--data or --file)
+ *   gufi row:delete <table> <id> Delete a row
+ *   gufi row:duplicate <table> <id> Duplicate a row
+ *   gufi rows:create <table>    Bulk create from JSON file
  */
 import { Command } from "commander";
 import { loginCommand, logoutCommand, whoamiCommand } from "./commands/login.js";
@@ -29,6 +38,7 @@ import { watchCommand } from "./commands/watch.js";
 import { listCommand } from "./commands/list.js";
 import { logsCommand } from "./commands/logs.js";
 import { companiesCommand, modulesCommand, moduleCommand, moduleUpdateCommand, companyCreateCommand, automationsCommand, automationCommand, } from "./commands/companies.js";
+import { rowsListCommand, rowGetCommand, rowCreateCommand, rowUpdateCommand, rowDeleteCommand, rowDuplicateCommand, rowsBulkCreateCommand, } from "./commands/rows.js";
 const program = new Command();
 program
     .name("gufi")
@@ -114,4 +124,45 @@ program
     .option("-c, --company <id>", "Company ID (if not default)")
     .option("-f, --file <path>", "Save code to file")
     .action(automationCommand);
+// ════════════════════════════════════════════════════════════════════
+// Row CRUD Commands - Create, Read, Update, Delete rows
+// ════════════════════════════════════════════════════════════════════
+program
+    .command("rows <table>")
+    .description("List rows from a table")
+    .option("-l, --limit <n>", "Number of rows to fetch", "20")
+    .option("-o, --offset <n>", "Starting offset", "0")
+    .option("-s, --sort <field>", "Sort by field", "id")
+    .option("--order <dir>", "Sort order (ASC/DESC)", "DESC")
+    .option("-f, --filter <expr>", "Filter expression (field=value)")
+    .action(rowsListCommand);
+program
+    .command("row <table> <id>")
+    .description("Get a single row by ID")
+    .action(rowGetCommand);
+program
+    .command("row:create <table>")
+    .description("Create a new row")
+    .option("-d, --data <json>", "JSON data for the row")
+    .option("-f, --file <path>", "JSON file with row data")
+    .action(rowCreateCommand);
+program
+    .command("row:update <table> <id>")
+    .description("Update a row by ID")
+    .option("-d, --data <json>", "JSON data to update")
+    .option("-f, --file <path>", "JSON file with update data")
+    .action(rowUpdateCommand);
+program
+    .command("row:delete <table> <id>")
+    .description("Delete a row by ID")
+    .action(rowDeleteCommand);
+program
+    .command("row:duplicate <table> <id>")
+    .description("Duplicate an existing row")
+    .action(rowDuplicateCommand);
+program
+    .command("rows:create <table>")
+    .description("Bulk create rows from JSON file")
+    .option("-f, --file <path>", "JSON file with array of rows")
+    .action(rowsBulkCreateCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gufi-cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "CLI for developing Gufi Marketplace views locally with Claude Code",
   "bin": {
     "gufi": "./bin/gufi.js"