@dataramen/cli 0.0.8 → 0.0.10

package/dist/code/repository/db.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueriesRepository = exports.WorkbookRepository = exports.UserSettingsRepository = exports.UserRepository = exports.TeamRepository = exports.DataSourceRepository = exports.DatabaseInspectionRepository = exports.init = exports.AppDataSource = void 0;
+const typeorm_1 = require("typeorm");
+const databaseInspection_1 = require("./tables/databaseInspection");
+const teams_1 = require("./tables/teams");
+const users_1 = require("./tables/users");
+const userSettings_1 = require("./tables/userSettings");
+const workbook_1 = require("./tables/workbook");
+const datasource_1 = require("./tables/datasource");
+const os_1 = __importDefault(require("os"));
+const query_1 = require("./tables/query");
+function getDatabaseValue() {
+    let value = process.env.TYPEORM_DATABASE;
+    if (!value) {
+        throw new Error("Bad value for TYPEORM_DATABASE. Please check your config!");
+    }
+    if (value.startsWith("<home>")) {
+        value = value.replace("<home>", os_1.default.homedir());
+    }
+    return value;
+}
+exports.AppDataSource = new typeorm_1.DataSource({
+    type: process.env.TYPEORM_CONNECTION,
+    database: getDatabaseValue(),
+    synchronize: process.env.TYPEORM_SYNCHRONIZE === 'true',
+    host: process.env.TYPEORM_HOST,
+    username: process.env.TYPEORM_USERNAME,
+    password: process.env.TYPEORM_PASSWORD,
+    port: process.env.TYPEORM_PORT ? parseInt(process.env.TYPEORM_PORT) : undefined,
+    logging: process.env.TYPEORM_LOGGING === 'true',
+    entities: [
+        databaseInspection_1.DatabaseInspection,
+        datasource_1.DataSource,
+        teams_1.Team,
+        users_1.User,
+        userSettings_1.UserSettings,
+        workbook_1.Workbook,
+        query_1.Query,
+    ],
+});
+const init = async () => {
+    if (!exports.AppDataSource.isInitialized) {
+        return exports.AppDataSource.initialize();
+    }
+    throw new Error("Already initialized");
+};
+exports.init = init;
+exports.DatabaseInspectionRepository = exports.AppDataSource.getRepository(databaseInspection_1.DatabaseInspection);
+exports.DataSourceRepository = exports.AppDataSource.getRepository(datasource_1.DataSource);
+exports.TeamRepository = exports.AppDataSource.getRepository(teams_1.Team);
+exports.UserRepository = exports.AppDataSource.getRepository(users_1.User);
+exports.UserSettingsRepository = exports.AppDataSource.getRepository(userSettings_1.UserSettings);
+exports.WorkbookRepository = exports.AppDataSource.getRepository(workbook_1.Workbook);
+exports.QueriesRepository = exports.AppDataSource.getRepository(query_1.Query);

package/dist/code/repository/tables/databaseInspection.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseInspection = void 0;
+const typeorm_1 = require("typeorm");
+exports.DatabaseInspection = new typeorm_1.EntitySchema({
+    name: "DatabaseInspection",
+    tableName: "db_inspection",
+    columns: {
+        id: {
+            type: String,
+            unique: true,
+            primary: true,
+            generated: "uuid",
+        },
+        tableName: {
+            nullable: true,
+            type: String,
+        },
+        columns: {
+            type: "json",
+            nullable: true,
+        },
+        createdAt: {
+            type: "datetime",
+            default: "CURRENT_TIMESTAMP",
+        },
+        updatedAt: {
+            type: "datetime",
+            default: "CURRENT_TIMESTAMP",
+        },
+    },
+    relations: {
+        datasource: {
+            target: () => "DataSource",
+            type: "many-to-one",
+            joinTable: false,
+            cascade: true,
+        },
+    },
+});

package/dist/code/repository/tables/datasource.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSource = void 0;
+const typeorm_1 = require("typeorm");
+exports.DataSource = new typeorm_1.EntitySchema({
+    name: "DataSource",
+    tableName: "data_sources",
+    columns: {
+        id: {
+            type: "uuid",
+            primary: true,
+            generated: "uuid",
+        },
+        dbUrl: {
+            type: String,
+        },
+        dbPort: {
+            type: Number,
+            nullable: true,
+        },
+        dbUser: {
+            type: String,
+        },
+        dbPassword: {
+            type: String,
+            nullable: true,
+        },
+        dbType: {
+            type: String,
+        },
+        createdAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+        updatedAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+        name: {
+            type: String,
+        },
+        description: {
+            type: String,
+            nullable: true,
+        },
+        dbDatabase: {
+            type: String,
+        },
+        dbSchema: {
+            type: String,
+            nullable: true,
+        },
+        lastInspected: {
+            type: "datetime",
+            nullable: true,
+            default: () => null,
+        },
+        status: {
+            type: String,
+            nullable: true,
+        },
+    },
+    relations: {
+        team: {
+            type: "many-to-one",
+            target: () => "Team",
+            inverseSide: "datasources",
+            joinColumn: true,
+        },
+        inspections: {
+            type: "one-to-many",
+            target: () => "DatabaseInspection",
+            inverseSide: "datasource",
+        },
+        queries: {
+            type: "one-to-many",
+            target: () => "Query",
+            inverseSide: "dataSource",
+        },
+        owner: {
+            type: "many-to-one",
+            target: () => "User",
+            joinColumn: true,
+        },
+    },
+});

package/dist/code/repository/tables/query.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const typeorm_1 = require("typeorm");
+exports.Query = new typeorm_1.EntitySchema({
+    name: "Query",
+    tableName: "query",
+    columns: {
+        id: {
+            type: "uuid",
+            primary: true,
+            generated: "uuid",
+        },
+        name: {
+            type: String,
+        },
+        opts: {
+            type: "json",
+            default: "{}",
+        },
+        isTrash: {
+            type: Boolean,
+            default: false,
+            nullable: true,
+        },
+        createdAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+        updatedAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+            onUpdate: "CURRENT_TIMESTAMP",
+        },
+    },
+    relations: {
+        team: {
+            type: "many-to-one",
+            target: () => "Team",
+            inverseSide: "workbooks",
+            joinColumn: true,
+        },
+        dataSource: {
+            type: "many-to-one",
+            target: () => "DataSource",
+            inverseSide: "queries",
+            joinColumn: true,
+        },
+    },
+});

package/dist/code/repository/tables/teams.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+const typeorm_1 = require("typeorm");
+exports.Team = new typeorm_1.EntitySchema({
+    name: "Team",
+    tableName: "teams",
+    columns: {
+        id: {
+            type: "uuid",
+            primary: true,
+            generated: "uuid",
+        },
+        name: {
+            type: String,
+        },
+        createdAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+        updatedAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+    },
+    relations: {
+        users: {
+            type: "many-to-many",
+            target: () => "User",
+            inverseSide: "teams",
+        },
+        workbooks: {
+            type: "one-to-many",
+            target: () => "Workbook",
+            inverseSide: "team",
+        },
+        queries: {
+            type: "one-to-many",
+            target: () => "Query",
+            inverseSide: "team",
+        },
+        datasources: {
+            type: "one-to-many",
+            target: () => "DataSource",
+            inverseSide: "team",
+        },
+    },
+});

package/dist/code/repository/tables/userSettings.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSettings = void 0;
+const typeorm_1 = require("typeorm");
+exports.UserSettings = new typeorm_1.EntitySchema({
+    name: "UserSettings",
+    tableName: "user_settings",
+    columns: {
+        id: {
+            type: "uuid",
+            primary: true,
+            generated: "uuid",
+        },
+        openAiToken: {
+            type: String,
+            nullable: true,
+        },
+        model: {
+            type: String,
+            default: "gpt-3.5-turbo",
+        },
+        createdAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+        updatedAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+    },
+    relations: {
+        user: {
+            type: "one-to-one",
+            target: () => "User",
+            inverseSide: "settings",
+            joinColumn: true,
+        },
+    },
+});

package/dist/code/repository/tables/users.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const typeorm_1 = require("typeorm");
+exports.User = new typeorm_1.EntitySchema({
+    name: "User",
+    tableName: "users",
+    columns: {
+        id: {
+            type: "uuid",
+            primary: true,
+            generated: "uuid",
+        },
+        createdAt: {
+            type: "datetime",
+            default: "CURRENT_TIMESTAMP",
+        },
+        updatedAt: {
+            type: "datetime",
+            default: "CURRENT_TIMESTAMP",
+        },
+    },
+    relations: {
+        teams: {
+            type: "many-to-many",
+            target: () => "Team",
+            inverseSide: "users",
+            joinTable: true,
+        },
+        settings: {
+            type: "one-to-one",
+            target: () => "UserSettings",
+            inverseSide: "user",
+            joinColumn: true,
+        },
+        currentTeam: {
+            type: "many-to-one",
+            target: () => "Team",
+            joinColumn: true,
+        },
+    },
+});

package/dist/code/repository/tables/workbook.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workbook = void 0;
+const typeorm_1 = require("typeorm");
+exports.Workbook = new typeorm_1.EntitySchema({
+    name: "Workbook",
+    tableName: "workbooks",
+    columns: {
+        id: {
+            type: "uuid",
+            primary: true,
+            generated: "uuid",
+        },
+        name: {
+            type: String,
+        },
+        path: {
+            type: "uuid",
+            generated: "uuid",
+        },
+        isTrash: {
+            type: "boolean",
+            default: false,
+        },
+        createdAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+        },
+        updatedAt: {
+            type: "datetime",
+            default: () => "CURRENT_TIMESTAMP",
+            onUpdate: "CURRENT_TIMESTAMP",
+        },
+    },
+    relations: {
+        team: {
+            type: "many-to-one",
+            target: () => "Team",
+            inverseSide: "workbooks",
+            joinColumn: true,
+        },
+    },
+});

package/dist/code/services/connectorManager/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDynamicConnection = void 0;
+const mysqlConnector_1 = require("../mysqlConnector");
+const httpError_1 = require("../../utils/httpError");
+const pgConnector_1 = require("../pgConnector");
+const getDynamicConnection = async (datasource, req) => {
+    try {
+        let dbConnectionManager;
+        if (datasource.dbType === "mysql") {
+            dbConnectionManager = await (0, mysqlConnector_1.MySqlConnector)(datasource);
+        }
+        else if (datasource.dbType === "postgres") {
+            dbConnectionManager = await (0, pgConnector_1.PGSqlConnector)(datasource);
+        }
+        else {
+            throw new httpError_1.HttpError(500, `Connection manager for ${datasource.dbType} not found`);
+        }
+        if (!req.__connections) {
+            req.__connections = [dbConnectionManager];
+        }
+        else {
+            req.__connections.push(dbConnectionManager);
+        }
+        return dbConnectionManager;
+    }
+    catch (error) {
+        console.error(error);
+        if (error instanceof httpError_1.HttpError) {
+            throw error;
+        }
+        if (error?.code === "ECONNREFUSED") {
+            throw new httpError_1.HttpError(500, "Failed to connect to the database");
+        }
+        throw new httpError_1.HttpError(500, error.message);
+    }
+};
+exports.getDynamicConnection = getDynamicConnection;

package/dist/code/services/connectorManager/types.js

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

package/dist/code/services/files/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupProjectFolders = exports.deleteFile = exports.storeFile = exports.getFile = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = require("node:path");
+const node_os_1 = __importDefault(require("node:os"));
+const homeDir = node_os_1.default.homedir();
+const filesPath = (0, node_path_1.join)(homeDir, ".dataramen", ".runtime", "files");
+const getPath = (path) => {
+    return (0, node_path_1.join)(filesPath, path);
+};
+const getFile = async (path) => {
+    return promises_1.default.readFile(getPath(path), { encoding: "utf8" });
+};
+exports.getFile = getFile;
+const storeFile = async (path, content) => {
+    return promises_1.default.writeFile(getPath(path), content, { encoding: "utf8" });
+};
+exports.storeFile = storeFile;
+const deleteFile = async (path) => {
+    return promises_1.default.unlink(getPath(path));
+};
+exports.deleteFile = deleteFile;
+const setupProjectFolders = async () => {
+    const hasFilesFolder = await filesFolderExists();
+    if (!hasFilesFolder) {
+        await promises_1.default.mkdir(filesPath, {
+            recursive: true
+        });
+    }
+};
+exports.setupProjectFolders = setupProjectFolders;
+async function filesFolderExists() {
+    try {
+        const result = await promises_1.default.lstat(filesPath);
+        return result.isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/code/services/mysqlConnector/index.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlConnector = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+const httpError_1 = require("../../utils/httpError");
+const getConnection = ({ dbDatabase, dbPassword, dbUser, dbUrl }) => {
+    return promise_1.default.createConnection({
+        host: dbUrl,
+        user: dbUser,
+        database: dbDatabase,
+        password: dbPassword,
+        // TODO: timeout?
+    });
+};
+const extractPrimaryKeys = async (connection) => {
+    const query = `
+      SELECT TABLE_NAME, COLUMN_NAME, ORDINAL_POSITION
+      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+      WHERE CONSTRAINT_NAME = 'PRIMARY'
+      ORDER BY TABLE_NAME, ORDINAL_POSITION;
+  `;
+    const [rows] = await connection.execute(query);
+    const primaryKeysMap = {};
+    rows.forEach(row => {
+        const tableName = row.TABLE_NAME;
+        const columnName = row.COLUMN_NAME;
+        if (!primaryKeysMap[tableName]) {
+            primaryKeysMap[tableName] = [];
+        }
+        primaryKeysMap[tableName].push(columnName);
+    });
+    return primaryKeysMap;
+};
+const getReferences = async (connection) => {
+    const query = `
+      SELECT
+          TABLE_NAME AS table_name,
+          COLUMN_NAME AS field,
+          REFERENCED_TABLE_NAME AS referenced_table,
+          REFERENCED_COLUMN_NAME AS referenced_field
+      FROM
+          information_schema.KEY_COLUMN_USAGE
+      WHERE
+          REFERENCED_TABLE_NAME IS NOT NULL
+        AND CONSTRAINT_SCHEMA = DATABASE();
+  `;
+    const [rows] = await connection.execute(query);
+    const result = {};
+    if (Array.isArray(rows)) {
+        rows.forEach((row) => {
+            if (!result[row.table_name]) {
+                result[row.table_name] = {};
+            }
+            result[row.table_name][row.field] = {
+                refTable: row.referenced_table,
+                refField: row.referenced_field
+            };
+        });
+    }
+    return result;
+};
+const inspectSchema = async (dataSource, connection) => {
+    const result = await connection.query('SHOW TABLES');
+    const tables = result[0];
+    const refs = await getReferences(connection);
+    const primaryKeys = await extractPrimaryKeys(connection);
+    const rows = tables.map(async (table) => {
+        const tableName = Object.values(table)[0];
+        const inspectColumnsQuery = `select COLUMN_NAME, DATA_TYPE from information_schema.columns where table_schema = '${dataSource.dbDatabase}' and table_name = '${tableName}'`;
+        const [columns] = await connection.query(inspectColumnsQuery);
+        const ref = refs[tableName];
+        return {
+            columns: columns
+                .map((column) => ({
+                name: column.COLUMN_NAME,
+                type: column.DATA_TYPE,
+                isPrimary: primaryKeys[tableName]?.includes(column.COLUMN_NAME),
+                ref: ref?.[column.COLUMN_NAME] ? {
+                    table: ref[column.COLUMN_NAME].refTable,
+                    field: ref[column.COLUMN_NAME].refField,
+                } : undefined,
+            }))
+                .sort((col1, col2) => {
+                if (col1.isPrimary && col2.isPrimary) {
+                    return col1.name.localeCompare(col2.name);
+                }
+                return col1.isPrimary ? -1 : 1;
+            }),
+            createdAt: new Date(),
+            tableName,
+            updatedAt: new Date(),
+        };
+    });
+    return Promise.all(rows);
+};
+const executeQuery = async (query, connection, opts) => {
+    try {
+        console.log(`[MYSQL CONN] Query: ${query}`);
+        const [result, columns] = await connection.query({
+            sql: query,
+            rowsAsArray: true,
+        });
+        const responseType = result?.constructor?.name;
+        if (responseType === "ResultSetHeader") {
+            // UPDATE, INSERT, DELETE
+            const resultSet = result;
+            if (resultSet.affectedRows > 3 && opts.allowBulkUpdate !== true) {
+                throw new Error(`[MYSQL CONN] Bulk update performed without permission.`);
+            }
+            return {
+                columns: [{ column: "affectedRows", alias: "Affected rows", full: "affectedRows" }],
+                rows: [[resultSet.affectedRows]],
+                query,
+            };
+        }
+        else if (responseType === "Array") {
+            const rows = result; // todo: type
+            return {
+                columns: columns?.map((column) => ({
+                    column: column.orgName || column.name,
+                    table: column.orgTable,
+                    alias: column.name,
+                    full: column.orgTable ? column.orgTable + "." + column.orgName : column.name,
+                })) || [],
+                rows,
+                query,
+            };
+        }
+        throw new Error(`[MYSQL CONN] Unknown result type: ${responseType}`);
+    }
+    catch (e) {
+        console.error(e);
+        if (e instanceof httpError_1.HttpError) {
+            throw e;
+        }
+        throw new httpError_1.HttpError(400, e.message);
+    }
+};
+const withTransaction = async (connection, fn) => {
+    await connection.beginTransaction();
+    try {
+        const result = await fn();
+        await connection.commit();
+        console.log("[MYSQL CONN] Commit");
+        return result;
+    }
+    catch (e) {
+        await connection.rollback();
+        console.warn(e.message);
+        console.log("[MYSQL CONN] Rollback");
+        throw e;
+    }
+};
+const MySqlConnector = async (dataSource) => {
+    const connection = await getConnection(dataSource);
+    let _isClosed = false;
+    return {
+        dbType: 'mysql',
+        dataSource,
+        inspectSchema: () => inspectSchema(dataSource, connection),
+        executeQuery: (query, opts) => {
+            if (opts.type === "SELECT") {
+                return executeQuery(query, connection, opts);
+            }
+            return withTransaction(connection, () => executeQuery(query, connection, opts));
+        },
+        checkConnection: async () => connection.ping(),
+        isClosed: () => _isClosed,
+        close: async () => {
+            if (_isClosed)
+                return;
+            _isClosed = true;
+            return connection.destroy();
+        },
+    };
+};
+exports.MySqlConnector = MySqlConnector;

package/dist/code/services/oauthClient/oauth2Client.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenInfoFromRequest = void 0;
+const getTokenInfoFromRequest = async (request) => {
+    return {
+        email: "local@localhost",
+        sub: "local",
+    };
+};
+exports.getTokenInfoFromRequest = getTokenInfoFromRequest;