@dataramen/cli 0.0.9 → 0.0.10

package/dist/README.md

@@ -0,0 +1,67 @@
+# 🍜 Data Ramen CLI
+
+**Your cozy corner for exploring and working with SQL databases — no query writing required (unless you want to).**
+
+Data Ramen CLI lets you launch a powerful, local database exploration app that connects effortlessly to MySQL and PostgreSQL databases. Browse schemas, follow relationships, insert data, and even write raw SQL — all from your browser.
+
+## ✨ Features
+
+- 🔌 **Connect to PostgreSQL & MySQL**  
+  Securely plug in your credentials — you're ready to explore.
+
+- 🧭 **Visual Schema Explorer**  
+  Instantly browse tables, columns, types, primary/foreign keys, and relationships.
+
+- 🧙 **No-SQL Querying**  
+  Filter, sort, join, and summarize data using a beautiful, intuitive interface.
+
+- 🔗 **Follow Relationships Easily**  
+  Click to expand related records like nested tables.
+
+- ✏️ **Insert & Update Visually**  
+  Add or modify rows with a visual editor — no SQL errors.
+
+- 💾 **Save Queries**  
+  Save your favorite views for quick access later.
+
+- ⌨️ **Raw SQL Mode Available**  
+  Prefer typing? Drop into SQL mode anytime and run your own queries.
+
+## 🛠️ Installation
+
+### 1. Install Node.js
+
+Data Ramen requires Node.js **v22 or above**.  
+👉 [Download Node.js](https://nodejs.org/)
+
+### 2. Install Data Ramen CLI
+
+Open your terminal and run:
+
+```bash
+npm i -g @dataramen/cli
+```
+
+## 🖥️ Usage
+
+### Start the Local Server
+
+```bash
+dataramen start
+```
+
+### Open the App
+
+Go to https://app.dataramen.xyz in your browser. Your local server will connect automatically.
+
+## 🔧 Additional CLI Commands
+
+| Command           | Description                       |
+| ----------------- | --------------------------------- |
+| `dataramen start` | Start the local Data Ramen server |
+| `dataramen stop`  | Stop the local server             |
+| `dataramen logs`  | Show logs from the running server |
+
+## ❤️ Made with love by [Oleksandr Demian](https://github.com/OleksandrDemian)
+
+Visit [dataramen.xyz](https://dataramen.xyz) for more info.

package/dist/code/api/chat/router.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const httpError_1 = require("../../utils/httpError");
+const prompts_1 = require("../../utils/prompts");
+const db_1 = require("../../repository/db");
+async function getDbString(datastoreId) {
+    const inspections = await db_1.DatabaseInspectionRepository.findBy({
+        datasource: {
+            id: datastoreId,
+        }
+    });
+    return (0, prompts_1.buildDbString)(inspections);
+}
+async function getAiCallInfo(userId) {
+    const userSettings = await db_1.UserSettingsRepository.findOneBy({
+        id: userId,
+    });
+    const openAiToken = userSettings?.openAiToken;
+    if (!openAiToken) {
+        throw new httpError_1.HttpError(400, "API key not found. Please set API key in settings");
+    }
+    return {
+        model: userSettings?.model || "gpt-4o",
+        token: openAiToken,
+    };
+}
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    // workbook chat
+    instance.post("/workbook", async (request) => {
+        // const userId = getRequestUserId(request);
+        // const { messages, id } = getRequestPayload<{ messages: TOpenAiMessage[]; id: string; }>(request);
+        // const workbook = await Workbook.findByPk(id);
+        // if (!workbook) {
+        //   throw new Error("Workbook not found");
+        // }
+        // const { model, token } = await getAiCallInfo(userId);
+        // const dbString = await getDbString(workbook.getDataValue("dataSourceId"));
+        // const { choices } = await executePrompt({
+        //   openaiApiKey: token,
+        //   temperature: 0.5,
+        //   messages: [
+        //     {
+        //       role: "system",
+        //       content: `You are a database administrator and your role is to assist the user while writing queries. This is the database schema:\n${dbString}.\n\nThe current workbook is:\n${workbook.getDataValue("text")}`,
+        //     },
+        //     ...messages
+        //   ],
+        //   model,
+        // });
+        return {
+            data: "", //choices[0].message,
+        };
+    });
+});

package/dist/code/api/dataSources/router.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const request_1 = require("../../utils/request");
+const validators_1 = require("./validators");
+const httpError_1 = require("../../utils/httpError");
+const connectorManager_1 = require("../../services/connectorManager");
+const db_1 = require("../../repository/db");
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    // get datasource by id
+    instance.get("/:id", async (request) => {
+        const { id } = (0, request_1.getRequestParams)(request);
+        const dataSource = await db_1.DataSourceRepository.findOne({
+            where: {
+                id,
+            }
+        });
+        if (!dataSource) {
+            throw new httpError_1.HttpError(404, "Data source not found");
+        }
+        return {
+            data: dataSource,
+        };
+    });
+    instance.get("/", async (request) => {
+        const { teamId } = (0, request_1.getRequestQuery)(request);
+        const dataSources = await db_1.DataSourceRepository.find({
+            where: {
+                team: {
+                    id: teamId,
+                },
+            },
+            order: {
+                createdAt: "DESC",
+            },
+        });
+        return {
+            data: dataSources,
+        };
+    });
+    // create data source
+    instance.post("/", async (request, reply) => {
+        const { teamId, ownerId, ...proto } = (0, request_1.getRequestPayload)(request, validators_1.validateCreateDataSource);
+        const dataSource = db_1.DataSourceRepository.create({
+            ...proto,
+            team: {
+                id: teamId,
+            },
+            owner: {
+                id: ownerId,
+            }
+        });
+        const connection = await (0, connectorManager_1.getDynamicConnection)(dataSource, request);
+        try {
+            await connection.checkConnection();
+        }
+        catch (e) {
+            throw new httpError_1.HttpError(400, "Cannot connect to the database, please check datasource configuration");
+        }
+        const createdDataSource = await db_1.DataSourceRepository.save(dataSource);
+        return {
+            data: createdDataSource,
+        };
+    });
+    // update datasource
+    instance.put("/:id", async (request, reply) => {
+        const { id } = (0, request_1.getRequestParams)(request);
+        const payload = (0, request_1.getRequestPayload)(request);
+        const dataSource = await db_1.DataSourceRepository.findOneBy({
+            id,
+        });
+        if (!dataSource) {
+            throw new httpError_1.HttpError(404, "Data source not found");
+        }
+        const updated = db_1.DataSourceRepository.merge(dataSource, payload);
+        await db_1.DataSourceRepository.save(updated);
+        return {
+            data: updated,
+        };
+    });
+    // remove datasource
+    instance.delete("/:id", async (request, reply) => {
+        return db_1.AppDataSource.transaction(async () => {
+            const { id } = (0, request_1.getRequestParams)(request);
+            await Promise.all([
+                db_1.DatabaseInspectionRepository.delete({
+                    datasource: {
+                        id,
+                    }
+                }),
+                db_1.QueriesRepository.delete({
+                    dataSource: {
+                        id,
+                    },
+                }),
+            ]);
+            await db_1.DataSourceRepository.delete({
+                id,
+            });
+        });
+    });
+    // inspect datasource
+    instance.post("/:id/inspect", async (request, reply) => {
+        const { id } = (0, request_1.getRequestParams)(request);
+        const dataSource = await db_1.DataSourceRepository.findOneBy({
+            id,
+        });
+        if (!dataSource) {
+            throw new Error("Data source not found");
+        }
+        dataSource.status = "INSPECTING";
+        await db_1.DataSourceRepository.save(dataSource);
+        const connection = await (0, connectorManager_1.getDynamicConnection)(dataSource, request);
+        // inspect dataSource
+        const inspection = await connection.inspectSchema();
+        // destroy previous inspections
+        await db_1.DatabaseInspectionRepository.delete({
+            datasource: {
+                id,
+            }
+        });
+        await db_1.DatabaseInspectionRepository.insert(inspection.sort().map((i) => db_1.DatabaseInspectionRepository.create({
+            tableName: i.tableName,
+            columns: i.columns,
+            datasource: {
+                id,
+            },
+        })));
+        // update datasource last inspected
+        dataSource.status = "READY";
+        dataSource.lastInspected = new Date();
+        await db_1.DataSourceRepository.save(dataSource);
+    });
+    instance.get("/:id/inspections", async (request, reply) => {
+        const { id } = (0, request_1.getRequestParams)(request);
+        const inspections = await db_1.DatabaseInspectionRepository.find({
+            where: {
+                datasource: {
+                    id,
+                }
+            },
+        });
+        return {
+            data: inspections,
+        };
+    });
+});

package/dist/code/api/dataSources/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/code/api/dataSources/validators.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCreateDataSource = void 0;
+const httpError_1 = require("../../utils/httpError");
+const validateCreateDataSource = (dataSource) => {
+    if (!dataSource.dbUrl) {
+        throw new httpError_1.HttpError(400, "url is required");
+    }
+    if (!dataSource.dbUser) {
+        throw new httpError_1.HttpError(400, "user is required");
+    }
+    if (!dataSource.dbType) {
+        throw new httpError_1.HttpError(400, "type is required");
+    }
+    if (!dataSource.name) {
+        throw new httpError_1.HttpError(400, "name is required");
+    }
+    if (!dataSource.dbDatabase) {
+        throw new httpError_1.HttpError(400, "database is required");
+    }
+};
+exports.validateCreateDataSource = validateCreateDataSource;

package/dist/code/api/project/router.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const request_1 = require("../../utils/request");
+const db_1 = require("../../repository/db");
+const typeorm_1 = require("typeorm");
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    instance.get("/team/:teamId/files", async (request, reply) => {
+        const { teamId } = (0, request_1.getRequestParams)(request);
+        const query = {
+            where: {
+                team: {
+                    id: teamId,
+                },
+            },
+            order: {
+                name: 'ASC',
+            },
+            select: {
+                id: true,
+                name: true,
+                updatedAt: true,
+            }
+        };
+        const [dataSources = [], workbooks = [], queries = []] = await Promise.all([
+            db_1.DataSourceRepository.find(query),
+            db_1.WorkbookRepository.find({
+                ...query,
+                where: {
+                    ...query.where,
+                    isTrash: false,
+                }
+            }),
+            db_1.QueriesRepository.find({
+                ...query,
+                where: {
+                    ...query.where,
+                    isTrash: false,
+                }
+            })
+        ]);
+        return {
+            data: [
+                ...dataSources.map((d) => ({ ...d, type: "dataSource" })),
+                ...workbooks.map((w) => ({ ...w, type: "workbook" })),
+                ...queries.map((w) => ({ ...w, type: "query" })),
+            ],
+        };
+    });
+    instance.get("/team/:teamId/trash", async (request) => {
+        const { teamId } = (0, request_1.getRequestParams)(request);
+        const workbooks = await db_1.AppDataSource.query(`
+        select id, name, updatedAt
+        from workbooks
+        where teamId = '${teamId}' AND (isTrash = true OR isTrash IS NULL)
+        order by name asc
+        limit 100;
+    `);
+        return {
+            data: workbooks,
+        };
+    });
+    instance.get("/team/:teamId/tables", async (request) => {
+        const { teamId } = (0, request_1.getRequestParams)(request);
+        const { search, size } = (0, request_1.getRequestQuery)(request);
+        const tables = await db_1.DatabaseInspectionRepository.find({
+            where: {
+                tableName: (0, typeorm_1.Like)(`%${search}%`),
+                datasource: {
+                    team: {
+                        id: teamId,
+                    }
+                }
+            },
+            relations: {
+                datasource: true,
+            },
+            select: {
+                id: true,
+                tableName: true,
+                datasource: {
+                    name: true,
+                    id: true,
+                },
+            },
+            order: {
+                tableName: "ASC",
+            },
+            take: parseInt(size) || 20,
+        });
+        return {
+            data: tables.map(t => ({
+                name: t.tableName,
+                id: t.id,
+                dataSourceName: t.datasource?.name || '--',
+                dataSourceId: t.datasource?.id || '--',
+            })),
+        };
+    });
+});

package/dist/code/api/queries/router.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const request_1 = require("../../utils/request");
+const queryUtils_1 = require("../../utils/queryUtils");
+const httpError_1 = require("../../utils/httpError");
+const db_1 = require("../../repository/db");
+const typeorm_1 = require("typeorm");
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    instance.get("/", async (request) => {
+        const { dataSourceId, teamId, limit, orderBy, name } = (0, request_1.getRequestQuery)(request);
+        if (!dataSourceId && !teamId) {
+            throw new httpError_1.HttpError(400, "Either dsId or teamId is required");
+        }
+        const where = {
+            isTrash: false,
+        };
+        if (dataSourceId) {
+            where.dataSource = {
+                id: dataSourceId,
+            };
+        }
+        if (teamId) {
+            where.team = {
+                id: teamId,
+            };
+        }
+        if (name) {
+            where.name = (0, typeorm_1.Like)(`%${name}%`);
+        }
+        const queries = await db_1.QueriesRepository.find({
+            where,
+            take: limit,
+            order: (0, queryUtils_1.parseOrderQueryParam)(orderBy, {
+                createdAt: "DESC",
+            })
+        });
+        return {
+            data: queries,
+        };
+    });
+    instance.get("/:id", async (request) => {
+        const { id } = (0, request_1.getRequestParams)(request);
+        const query = await db_1.QueriesRepository.findOne({
+            where: {
+                id,
+            },
+            select: {
+                dataSource: {
+                    id: true,
+                },
+            },
+            relations: {
+                dataSource: true,
+            }
+        });
+        if (!query) {
+            return {
+                status: 404,
+                data: "Query not found",
+            };
+        }
+        return {
+            data: query,
+        };
+    });
+    instance.post("/", async (request) => {
+        const payload = (0, request_1.getRequestPayload)(request);
+        const dataSource = await db_1.DataSourceRepository.findOne({
+            where: {
+                id: payload.dataSourceId,
+            },
+            relations: {
+                team: true,
+            },
+        });
+        const query = await db_1.QueriesRepository.save(db_1.QueriesRepository.create({
+            name: payload.name,
+            isTrash: false,
+            opts: payload.opts,
+            team: {
+                id: dataSource?.team.id,
+            },
+            dataSource: {
+                id: payload.dataSourceId,
+            }
+        }));
+        return {
+            data: query,
+        };
+    });
+    // update workbook
+    instance.patch("/:id", async (request) => {
+        const { id } = (0, request_1.getRequestParams)(request);
+        const payload = (0, request_1.getRequestPayload)(request);
+        const result = await db_1.QueriesRepository.update(id, payload);
+        if (!result.affected) {
+            throw new httpError_1.HttpError(404, "Workbook not found");
+        }
+        const query = await db_1.QueriesRepository.findOneBy({
+            id,
+        });
+        return {
+            data: query,
+        };
+    });
+    // delete query
+    instance.delete("/:id", async (request) => {
+        return db_1.AppDataSource.transaction(async () => {
+            const { id } = (0, request_1.getRequestParams)(request);
+            const result = await db_1.QueriesRepository.delete({
+                id
+            });
+            if (!result.affected) {
+                return {
+                    status: 404,
+                    data: "Workbook not found",
+                };
+            }
+        });
+    });
+});

package/dist/code/api/runner/router.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const request_1 = require("../../utils/request");
+const userSqlPromptRunner_1 = require("../../services/userSqlPromptRunner");
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    // run sql
+    instance.post("/sql", async (request) => {
+        const payload = (0, request_1.getRequestPayload)(request);
+        const result = await (0, userSqlPromptRunner_1.runUserSqlQuery)(request, payload);
+        return {
+            data: result,
+        };
+    });
+    instance.post("/raw", async (request) => {
+        const payload = (0, request_1.getRequestPayload)(request);
+        const result = await (0, userSqlPromptRunner_1.runRawSqlQuery)(request, payload);
+        return {
+            data: result,
+        };
+    });
+});

package/dist/code/api/status/router.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const node_child_process_1 = require("node:child_process");
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    instance.get("/", async (request, reply) => {
+        return {
+            data: {
+                active: true,
+                version: process.env.SERVER_VERSION,
+            },
+        };
+    });
+    instance.get("/logs", async () => {
+        (0, node_child_process_1.spawn)(`echo "${process.env.SERVER_VERSION}"`);
+    });
+});

package/dist/code/api/teams/router.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const request_1 = require("../../utils/request");
+const db_1 = require("../../repository/db");
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    instance.get("/", async (request, reply) => {
+        const userId = (0, request_1.getRequestUserId)(request);
+        const teams = await db_1.TeamRepository.find({
+            where: {
+                users: {
+                    id: userId,
+                }
+            },
+        });
+        return {
+            data: teams,
+        };
+    });
+    // post
+    instance.post("/", async (request, reply) => {
+        return db_1.AppDataSource.transaction(async () => {
+            const userId = (0, request_1.getRequestUserId)(request);
+            const teamPayload = (0, request_1.getRequestPayload)(request);
+            const user = db_1.UserRepository.create();
+            user.id = userId;
+            const team = db_1.TeamRepository.create(teamPayload);
+            team.users = [user];
+            await db_1.TeamRepository.save(team);
+            return {
+                data: team,
+            };
+        });
+    });
+});

package/dist/code/api/userSettings/router.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouter_1 = require("../../utils/createRouter");
+const request_1 = require("../../utils/request");
+const httpError_1 = require("../../utils/httpError");
+const token_1 = require("../../utils/token");
+const db_1 = require("../../repository/db");
+function sanitizeFeSettings(settings) {
+    const newSettings = db_1.UserSettingsRepository.create(settings);
+    if (settings.openAiToken) {
+        newSettings.openAiToken = (0, token_1.sanitizeOpenAIToken)(settings.openAiToken);
+    }
+    return newSettings;
+}
+exports.default = (0, createRouter_1.createRouter)((instance) => {
+    // get user settings by user id
+    instance.get("/", async (req) => {
+        const userId = (0, request_1.getRequestUserId)(req);
+        let settings = await db_1.UserSettingsRepository.findOneBy({
+            user: {
+                id: userId,
+            }
+        });
+        if (!settings) {
+            // create default settings if not found
+            settings = await db_1.UserSettingsRepository.save(db_1.UserSettingsRepository.create({
+                user: {
+                    id: userId,
+                },
+                model: "gpt-4o",
+            }));
+        }
+        return {
+            data: sanitizeFeSettings(settings),
+        };
+    });
+    // update user settings
+    instance.patch("/", async (req) => {
+        const { settings } = (0, request_1.getRequestPayload)(req);
+        if (!settings.id) {
+            throw new httpError_1.HttpError(400, "Settings id is required!");
+        }
+        const result = await db_1.UserSettingsRepository.update(settings.id, settings);
+        if (!result.affected) {
+            throw new httpError_1.HttpError(404, "You do not own these settings!");
+        }
+        const updatedSettings = await db_1.UserSettingsRepository.findOneBy({
+            id: settings.id,
+        });
+        return {
+            data: updatedSettings,
+        };
+    });
+});