editdb-cli 1.0.0

package/src/constants.js

@@ -0,0 +1,36 @@
+export const CHOICES = {
+    DB_NEW: '__NEW__',
+    TABLE_NEW: '__NEW_TABLE__',
+    TABLE_CUSTOM_QUERY: '__CUSTOM_QUERY__',
+    EXIT: null,
+};
+
+export const UI_ACTIONS = {
+    ROW_SELECT: 'select',
+    ROW_MULTI_ACTION: 'multi',
+    ROW_INSERT: 'insert',
+    TABLE_ALTER: 'alter',
+    TABLE_SCHEMA: 'schema',
+    BACK: 'back',
+};
+
+export const ROW_ACTIONS = {
+    EDIT: 'edit',
+    DELETE: 'delete',
+};
+
+export const PAGINATION = {
+    NEXT: '__NEXT__',
+    PREV: '__PREV__',
+};
+
+export const ALTER_TABLE_ACTIONS = {
+    ADD_COLUMN: 'add_column',
+    DROP_COLUMN: 'drop_column',
+    RENAME_TABLE: 'rename_table',
+};
+
+export const MULTI_ROW_ACTIONS = {
+    UPDATE: 'update',
+    DELETE: 'delete',
+};

package/src/db.js

@@ -0,0 +1,176 @@
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs/promises';
+import { logger, isValidIdentifier } from './utils.js';
+import { CHOICES } from './constants.js';
+import { t } from './i18n.js';
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function selectDatabase(dbPath) {
+  if (dbPath) {
+    const resolvedPath = path.resolve(process.cwd(), dbPath);
+    if (!(await fileExists(resolvedPath))) {
+      const { createNew } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'createNew',
+          message: t('db.notFound', { dbPath }),
+          default: true,
+        },
+      ]);
+      if (!createNew) {
+        logger.warn(t('common.cancel'));
+        return null;
+      }
+      if (!resolvedPath.endsWith('.db') && !resolvedPath.endsWith('.sqlite')) {
+        logger.error(t('db.fileTypeError'));
+        return null;
+      }
+      logger.info(t('db.newDb', { dbName: path.basename(resolvedPath) }));
+    }
+    const db = new Database(resolvedPath);
+    logger.success(t('db.connected', { dbName: path.basename(resolvedPath) }));
+    return db;
+  }
+
+  const dbDir = process.cwd();
+  const files = await fs.readdir(dbDir);
+  const dbFiles = files.filter(
+    (f) => f.endsWith('.db') || f.endsWith('.sqlite')
+  );
+
+  const databaseCountMessage =
+    dbFiles.length > 0
+      ? t('db.selectDb', { count: dbFiles.length })
+      : t('db.selectDbNotFound');
+
+  const { dbFile } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'dbFile',
+      message: databaseCountMessage,
+      choices: [
+        ...dbFiles,
+        new inquirer.Separator(),
+        { name: t('db.newDbChoice'), value: CHOICES.DB_NEW },
+      ],
+    },
+  ]);
+
+  let resolvedDbPath;
+  if (dbFile === CHOICES.DB_NEW) {
+    const { newDbName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'newDbName',
+        message: t('db.newDbPrompt'),
+        validate: async (input) => {
+          if (!input) return t('db.newDbValidateEmpty');
+          if (!input.endsWith('.db') && !input.endsWith('.sqlite')) {
+            return t('db.fileTypeError');
+          }
+          if (await fileExists(path.resolve(dbDir, input))) {
+            return t('db.newDbValidateExists');
+          }
+          return true;
+        },
+      },
+    ]);
+    resolvedDbPath = path.resolve(dbDir, newDbName);
+    logger.info(t('db.newDb', { dbName: newDbName }));
+  } else {
+    resolvedDbPath = path.resolve(dbDir, dbFile);
+  }
+
+  const db = new Database(resolvedDbPath);
+  logger.success(t('db.connected', { dbName: path.basename(resolvedDbPath) }));
+  return db;
+}
+
+export function closeDatabase(db) {
+  db.close();
+  logger.info(`\n${t('db.connectionClosed')}`);
+}
+
+export function getTables(db) {
+  return db
+    .prepare(
+      `
+        SELECT name FROM sqlite_master
+        WHERE type='table' AND name NOT LIKE 'sqlite_%'
+    `
+    )
+    .all()
+    .map((t) => t.name);
+}
+
+export function getPrimaryKey(db, table) {
+  if (!isValidIdentifier(table))
+    throw new Error(`Invalid table name: ${table}`);
+  try {
+    const info = db.prepare(`PRAGMA table_info("${table}")`).all();
+    const pk = info.find((col) => col.pk === 1);
+    return pk ? pk.name : null;
+  } catch (err) {
+    logger.error(t('db.tableInfoError', { message: err.message }));
+    return null;
+  }
+}
+
+export function getAllRows(db, table) {
+  if (!isValidIdentifier(table))
+    throw new Error(`Invalid table name: ${table}`);
+  return db.prepare(`SELECT * FROM "${table}"`).all();
+}
+
+export function countRows(db, table) {
+  if (!isValidIdentifier(table))
+    throw new Error(`Invalid table name: ${table}`);
+  const { count } = db
+    .prepare(`SELECT COUNT(*) as count FROM "${table}"`)
+    .get();
+  return count;
+}
+
+export function getRowsPaginated(db, table, limit, offset) {
+  if (!isValidIdentifier(table))
+    throw new Error(`Invalid table name: ${table}`);
+  return db
+    .prepare(`SELECT * FROM "${table}" LIMIT ? OFFSET ?`)
+    .all(limit, offset);
+}
+
+export function getSingleRow(db, table, idKey, rowId) {
+  if (!isValidIdentifier(table))
+    throw new Error(`Invalid table name: ${table}`);
+  if (!isValidIdentifier(idKey))
+    throw new Error(`Invalid column name: ${idKey}`);
+  return db.prepare(`SELECT * FROM "${table}" WHERE "${idKey}" = ?`).get(rowId);
+}
+
+export function getTableInfo(db, table) {
+  if (!isValidIdentifier(table))
+    throw new Error(`Invalid table name: ${table}`);
+  return db.prepare(`PRAGMA table_info("${table}")`).all();
+}
+
+export function executeCustomQuery(db, sql, params = []) {
+  const trimmedSql = sql.trim().toUpperCase();
+  if (!trimmedSql.startsWith('SELECT')) {
+    throw new Error(t('db.readOnlyError'));
+  }
+  try {
+    return db.prepare(sql).all(params);
+  } catch (err) {
+    throw new Error(t('db.queryError', { message: err.message }));
+  }
+}

package/src/i18n.js

@@ -0,0 +1,62 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+let translations = {};
+let currentLang = 'en';
+
+function resolve(path, obj) {
+  return path.split('.').reduce((prev, curr) => {
+    return prev ? prev[curr] : null;
+  }, obj || self);
+}
+
+export async function init(language) {
+  let lang = language;
+
+  if (!lang) {
+    const envLang = process.env.LANG || 'en_US.UTF-8';
+    lang = envLang.split('.')[0].split('_')[0];
+  }
+
+  if (!['en', 'ja'].includes(lang)) {
+    lang = 'en';
+  }
+
+  currentLang = lang;
+
+  try {
+    const filePath = path.resolve(process.cwd(), `locales/${currentLang}.json`);
+    const fileContent = await fs.readFile(filePath, 'utf-8');
+    translations = JSON.parse(fileContent);
+  } catch (error) {
+    console.error(
+      `Could not load translations for '${currentLang}'. Falling back to English.`
+    );
+    currentLang = 'en';
+    const filePath = path.resolve(process.cwd(), `locales/en.json`);
+    const fileContent = await fs.readFile(filePath, 'utf-8');
+    translations = JSON.parse(fileContent);
+  }
+}
+
+export function t(key, replacements = {}) {
+  let translation = resolve(key, translations);
+
+  if (!translation) {
+    console.warn(`Translation not found for key: ${key}`);
+    return key;
+  }
+
+  for (const placeholder in replacements) {
+    translation = translation.replace(
+      new RegExp(`{${placeholder}}`, 'g'),
+      replacements[placeholder]
+    );
+  }
+
+  return translation;
+}
+
+export function getLang() {
+  return currentLang;
+}

package/src/index.js

@@ -0,0 +1,95 @@
+import { selectDatabase, closeDatabase } from './db.js';
+import { selectTable, tableActionPrompt } from './ui.js';
+import { createTable, executeCustomQueryAction } from './actions.js';
+import { logger } from './utils.js';
+import { init, getLang, t } from './i18n.js';
+import { CHOICES } from './constants.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const meta = await getMetaData();
+
+async function displayHelp() {
+  try {
+    const lang = getLang();
+    const helpMessagePath = path.resolve(
+      __dirname,
+      `../assets/help_message_${lang}.txt`
+    );
+
+    const helpContent = await fs.readFile(helpMessagePath, 'utf-8');
+
+    const rendered = helpContent
+      .replace(/\$\{meta\.version\}/g, meta.version ?? '')
+      .replace(/\$\{meta\.repositoryURL\}/g, meta.repository.url ?? '');
+
+    console.log(rendered);
+  } catch (error) {
+    logger.error(t('common.error'), error.message);
+  }
+}
+
+async function getMetaData() {
+  const packageJsonPath = path.resolve(__dirname, '../package.json');
+  const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+  return JSON.parse(packageJsonContent);
+}
+
+export async function main() {
+  const args = hideBin(process.argv);
+
+  const langArg = yargs(args.filter((a) => a !== '-h' && a !== '--help'))
+    .option('lang', { alias: 'l', type: 'string', choices: ['en', 'ja'] })
+    .help(false)
+    .version(false)
+    .parseSync();
+  await init(langArg.lang || null);
+
+  if (args.includes('-h') || args.includes('--help')) {
+    await displayHelp();
+    return;
+  }
+
+  const argv = yargs(args)
+    .version(meta.version)
+    .alias('v', 'version')
+    .positional('dbPath', {
+      describe: t('common.dbpath_description'),
+      type: 'string',
+    })
+    .help(false)
+    .parse();
+
+  let db;
+  try {
+    db = await selectDatabase(argv.dbPath);
+    if (!db) return;
+
+    while (true) {
+      const table = await selectTable(db);
+
+      if (table === CHOICES.TABLE_NEW) {
+        await createTable(db);
+      } else if (table === CHOICES.TABLE_CUSTOM_QUERY) {
+        await executeCustomQueryAction(db);
+      } else if (table) {
+        await tableActionPrompt(db, table);
+      } else {
+        break;
+      }
+    }
+  } catch (err) {
+    logger.error(`\n${t('common.error')}:`, err.message);
+    process.exit(1);
+  } finally {
+    if (db) {
+      closeDatabase(db);
+    }
+  }
+}