simplemdg-dev-cli 2.0.4 → 2.4.4

package/src/core/db/db-types.ts

@@ -0,0 +1,195 @@
+export type TDatabaseType = "hana" | "postgresql";
+
+export type TDatabaseConnectionProfile = {
+  id: string;
+  name: string;
+  type: TDatabaseType;
+  region?: string;
+  org?: string;
+  space?: string;
+  app?: string;
+  serviceName?: string;
+  servicePlan?: string;
+  host: string;
+  port: number;
+  database?: string;
+  schema?: string;
+  username: string;
+  encryptedPassword: string;
+  ssl?: boolean;
+  sslValidateCertificate?: boolean;
+  createdAt: string;
+  updatedAt: string;
+  lastUsedAt?: string;
+  tags?: string[];
+};
+
+/**
+ * A connection profile whose password has been decrypted for internal server
+ * use. This shape never leaves the local process boundary.
+ */
+export type TResolvedDatabaseConnection = Omit<TDatabaseConnectionProfile, "encryptedPassword"> & {
+  password: string;
+};
+
+/**
+ * A connection profile safe to send to the browser: no password material.
+ */
+export type TPublicDatabaseConnection = Omit<TDatabaseConnectionProfile, "encryptedPassword">;
+
+export type TDatabaseColumn = {
+  name: string;
+  dataType: string;
+  length?: number;
+  scale?: number;
+  nullable: boolean;
+  defaultValue?: string;
+  isPrimaryKey?: boolean;
+  comment?: string;
+  position?: number;
+};
+
+export type TDatabaseObjectKind =
+  | "table"
+  | "view"
+  | "column-view"
+  | "procedure"
+  | "function"
+  | "synonym"
+  | "index";
+
+export type TDatabaseObject = {
+  schema: string;
+  name: string;
+  kind: TDatabaseObjectKind;
+  type?: string;
+  comment?: string;
+};
+
+export type TDatabaseSchema = {
+  name: string;
+  isSystem: boolean;
+};
+
+export type TDatabaseIndex = {
+  name: string;
+  columns: string[];
+  isUnique: boolean;
+  isPrimaryKey: boolean;
+};
+
+export type TDatabaseQueryResult = {
+  fields: string[];
+  rows: Array<Record<string, unknown>>;
+  rowCount: number;
+  affectedRows?: number;
+  command?: string;
+  durationMs: number;
+  truncated?: boolean;
+};
+
+/**
+ * A database service candidate detected inside a parsed VCAP_SERVICES block.
+ * The password is kept here only transiently while importing from BTP.
+ */
+export type TDatabaseServiceCandidate = {
+  type: TDatabaseType;
+  label: string;
+  serviceName: string;
+  servicePlan?: string;
+  host: string;
+  port: number;
+  database?: string;
+  schema?: string;
+  username: string;
+  password: string;
+  ssl: boolean;
+  sslValidateCertificate?: boolean;
+};
+
+export type TBtpAppDatabaseImportContext = {
+  region?: string;
+  org?: string;
+  space?: string;
+  app?: string;
+};
+
+export type TSavedQuery = {
+  id: string;
+  name: string;
+  connectionType?: TDatabaseType;
+  connectionId?: string;
+  sql: string;
+  tags?: string[];
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type TQueryHistoryItem = {
+  id: string;
+  timestamp: string;
+  connectionId?: string;
+  connectionName?: string;
+  connectionType?: TDatabaseType;
+  sql: string;
+  durationMs: number;
+  success: boolean;
+  rowCount?: number;
+  error?: string;
+};
+
+export type TSqlSafetyAnalysis = {
+  isDestructive: boolean;
+  isReadOnly: boolean;
+  blockedByReadOnly: boolean;
+  matchedKeywords: string[];
+  reason?: string;
+};
+
+export type TConnectionTestResult = {
+  success: boolean;
+  message: string;
+  serverVersion?: string;
+  durationMs: number;
+};
+
+export type TListObjectsOptions = {
+  schema?: string;
+  kinds?: TDatabaseObjectKind[];
+  search?: string;
+};
+
+export type TTableDataOptions = {
+  schema: string;
+  table: string;
+  limit: number;
+  offset: number;
+  where?: string;
+  orderBy?: string;
+  orderDirection?: "asc" | "desc";
+};
+
+/**
+ * Common interface implemented by every database adapter. Adapters own dialect
+ * specifics (quoting, system catalog queries) so the rest of the studio is
+ * dialect-agnostic.
+ */
+export interface IDatabaseAdapter {
+  readonly type: TDatabaseType;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  testConnection(): Promise<TConnectionTestResult>;
+  runQuery(sql: string, options?: { maxRows?: number }): Promise<TDatabaseQueryResult>;
+  /** Run a parameterized statement. Placeholders come from `placeholder()`. */
+  runParameterized(sql: string, params: unknown[], options?: { maxRows?: number }): Promise<TDatabaseQueryResult>;
+  /** Dialect-specific bind placeholder for parameter N (1-based). */
+  placeholder(index: number): string;
+  listSchemas(): Promise<TDatabaseSchema[]>;
+  listObjects(options: TListObjectsOptions): Promise<TDatabaseObject[]>;
+  listColumns(schema: string, table: string): Promise<TDatabaseColumn[]>;
+  listIndexes(schema: string, table: string): Promise<TDatabaseIndex[]>;
+  countRows(schema: string, table: string): Promise<number>;
+  getTableData(options: TTableDataOptions): Promise<TDatabaseQueryResult>;
+  quoteIdentifier(identifier: string): string;
+  buildQualifiedName(schema: string, name: string): string;
+}

package/src/core/db/db-vcap-parser.ts

@@ -0,0 +1,182 @@
+import type { TDatabaseServiceCandidate, TDatabaseType } from "./db-types";
+
+type TVcapServiceEntry = {
+  name?: string;
+  instance_name?: string;
+  label?: string;
+  plan?: string;
+  tags?: unknown;
+  credentials?: Record<string, unknown>;
+};
+
+const HANA_HINTS = ["hana", "hana-cloud", "hanatrial", "hdi-shared", "hdi", "saphana"];
+const POSTGRES_HINTS = ["postgres", "postgresql", "timescale", "postgresql-db", "postgres-db"];
+
+function toStringValue(value: unknown): string {
+  if (value === undefined || value === null) {
+    return "";
+  }
+
+  return String(value);
+}
+
+function toNumberValue(value: unknown, fallback: number): number {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function toBooleanValue(value: unknown, fallback: boolean): boolean {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) return true;
+    if (["false", "0", "no", "off"].includes(normalized)) return false;
+  }
+
+  return fallback;
+}
+
+function buildHaystack(label: string, entry: TVcapServiceEntry, credentials: Record<string, unknown>): string {
+  const tags = Array.isArray(entry.tags) ? entry.tags.map(toStringValue).join(" ") : "";
+  const credentialUrl = `${toStringValue(credentials.url)} ${toStringValue(credentials.uri)}`;
+  return `${label} ${toStringValue(entry.label)} ${toStringValue(entry.name)} ${tags} ${credentialUrl}`.toLowerCase();
+}
+
+function matchesAnyHint(haystack: string, hints: string[]): boolean {
+  return hints.some((hint) => haystack.includes(hint));
+}
+
+function detectHanaCandidate(
+  label: string,
+  entry: TVcapServiceEntry,
+  credentials: Record<string, unknown>,
+): TDatabaseServiceCandidate | undefined {
+  const host = toStringValue(credentials.host ?? credentials.hostname);
+  const user = toStringValue(credentials.user ?? credentials.username ?? credentials.hdi_user);
+  const password = toStringValue(credentials.password ?? credentials.hdi_password);
+
+  if (!host || !user || !password) {
+    return undefined;
+  }
+
+  const schema = toStringValue(
+    credentials.schema ?? credentials.currentSchema ?? credentials.hdi_user ?? credentials.user,
+  );
+
+  return {
+    type: "hana",
+    label,
+    serviceName: toStringValue(entry.name ?? entry.instance_name ?? label),
+    servicePlan: toStringValue(entry.plan) || undefined,
+    host,
+    port: toNumberValue(credentials.port, 443),
+    database: toStringValue(credentials.databaseName ?? credentials.dbname) || undefined,
+    schema: schema || undefined,
+    username: user,
+    password,
+    ssl: toBooleanValue(credentials.encrypt, true),
+    sslValidateCertificate: toBooleanValue(credentials.sslValidateCertificate ?? credentials.validate_certificate, false),
+  };
+}
+
+function detectPostgresCandidate(
+  label: string,
+  entry: TVcapServiceEntry,
+  credentials: Record<string, unknown>,
+): TDatabaseServiceCandidate | undefined {
+  const rawUri = toStringValue(credentials.uri ?? credentials.url);
+  let parsedUri: URL | undefined;
+
+  if (rawUri && /^postg(res|resql)?:\/\//i.test(rawUri)) {
+    try {
+      parsedUri = new URL(rawUri);
+    } catch {
+      parsedUri = undefined;
+    }
+  }
+
+  const host = toStringValue(credentials.hostname ?? credentials.host ?? parsedUri?.hostname);
+  const username = toStringValue(credentials.username ?? credentials.user ?? parsedUri?.username);
+  const password = toStringValue(
+    credentials.password ?? (parsedUri?.password ? decodeURIComponent(parsedUri.password) : ""),
+  );
+
+  if (!host || !username || !password) {
+    return undefined;
+  }
+
+  const database = toStringValue(
+    credentials.dbname ?? credentials.database ?? parsedUri?.pathname.replace(/^\//, ""),
+  );
+
+  return {
+    type: "postgresql",
+    label,
+    serviceName: toStringValue(entry.name ?? entry.instance_name ?? label),
+    servicePlan: toStringValue(entry.plan) || undefined,
+    host,
+    port: toNumberValue(credentials.port ?? parsedUri?.port, 5432),
+    database: database || undefined,
+    schema: toStringValue(credentials.schema) || "public",
+    username,
+    password,
+    ssl: toBooleanValue(credentials.sslrootcert ? true : credentials.ssl, true),
+    sslValidateCertificate: toBooleanValue(credentials.sslValidateCertificate, false),
+  };
+}
+
+/**
+ * Inspect a parsed VCAP_SERVICES object and return every HANA / PostgreSQL
+ * service whose credentials are complete enough to connect.
+ */
+export function detectDatabaseServiceCandidates(vcapServices: unknown): TDatabaseServiceCandidate[] {
+  if (!vcapServices || typeof vcapServices !== "object") {
+    return [];
+  }
+
+  const candidates: TDatabaseServiceCandidate[] = [];
+
+  for (const [label, entries] of Object.entries(vcapServices as Record<string, unknown>)) {
+    if (!Array.isArray(entries)) {
+      continue;
+    }
+
+    for (const rawEntry of entries as TVcapServiceEntry[]) {
+      const credentials = (rawEntry.credentials ?? {}) as Record<string, unknown>;
+
+      if (Object.keys(credentials).length === 0) {
+        continue;
+      }
+
+      const haystack = buildHaystack(label, rawEntry, credentials);
+      const isHanaShaped = matchesAnyHint(haystack, HANA_HINTS);
+      const isPostgresShaped = matchesAnyHint(haystack, POSTGRES_HINTS) || /^postg(res|resql)?:\/\//i.test(toStringValue(credentials.uri ?? credentials.url));
+
+      if (isPostgresShaped) {
+        const postgres = detectPostgresCandidate(label, rawEntry, credentials);
+        if (postgres) {
+          candidates.push(postgres);
+          continue;
+        }
+      }
+
+      if (isHanaShaped) {
+        const hana = detectHanaCandidate(label, rawEntry, credentials);
+        if (hana) {
+          candidates.push(hana);
+        }
+      }
+    }
+  }
+
+  return candidates;
+}
+
+export function describeServiceCandidate(candidate: TDatabaseServiceCandidate): string {
+  const databaseTypeLabel: Record<TDatabaseType, string> = { hana: "HANA", postgresql: "PostgreSQL" };
+  const target = candidate.database || candidate.schema || candidate.host;
+  return `${candidate.serviceName} · ${databaseTypeLabel[candidate.type]} · ${target}`;
+}

package/src/core/doctor.ts

@@ -0,0 +1,70 @@
+import path from "node:path";
+import fs from "fs-extra";
+import type { TDoctorPackageResult, TPackageOccurrence } from "./types";
+
+async function findPackageJsonFiles(startPath: string, packageName: string): Promise<string[]> {
+  const packagePathParts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
+  const result: string[] = [];
+
+  async function walk(directoryPath: string, depth: number): Promise<void> {
+    if (depth > 8) {
+      return;
+    }
+
+    const entries = await fs.readdir(directoryPath, { withFileTypes: true }).catch(() => []);
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      if (entry.name === ".git") {
+        continue;
+      }
+
+      const entryPath = path.join(directoryPath, entry.name);
+
+      if (entry.name === "node_modules") {
+        const packageJsonPath = path.join(entryPath, ...packagePathParts, "package.json");
+
+        if (await fs.pathExists(packageJsonPath)) {
+          result.push(packageJsonPath);
+        }
+
+        await walk(entryPath, depth + 1);
+        continue;
+      }
+
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+
+      await walk(entryPath, depth + 1);
+    }
+  }
+
+  await walk(startPath, 0);
+  return result;
+}
+
+export async function doctorPackage(options: { repositoryPath: string; packageName: string }): Promise<TDoctorPackageResult> {
+  const packageJsonFiles = await findPackageJsonFiles(options.repositoryPath, options.packageName);
+  const occurrences: TPackageOccurrence[] = [];
+
+  for (const packageJsonFile of packageJsonFiles) {
+    const packageJson = await fs.readJson(packageJsonFile).catch(() => undefined) as { version?: string } | undefined;
+    occurrences.push({
+      version: packageJson?.version,
+      path: packageJsonFile,
+    });
+  }
+
+  const versions = [...new Set(occurrences.map((item) => item.version).filter((version): version is string => Boolean(version)))];
+
+  return {
+    packageName: options.packageName,
+    versions,
+    occurrences,
+    hasMultipleVersions: versions.length > 1,
+  };
+}

package/src/core/guide.ts

@@ -0,0 +1,261 @@
+import http from "node:http";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import fs from "fs-extra";
+import chalk from "chalk";
+import prompts from "prompts";
+
+const GUIDE_FILE_NAME = "USER_GUIDE.md";
+
+type TGuideMode = "terminal" | "web" | "commander-help";
+
+function getPackageRootPath(): string {
+  return path.resolve(__dirname, "..", "..");
+}
+
+async function readGuideMarkdown(): Promise<string> {
+  const packageRootPath = getPackageRootPath();
+  const guidePath = path.join(packageRootPath, GUIDE_FILE_NAME);
+
+  if (await fs.pathExists(guidePath)) {
+    return fs.readFile(guidePath, "utf8");
+  }
+
+  const readmePath = path.join(packageRootPath, "README.md");
+
+  if (await fs.pathExists(readmePath)) {
+    return fs.readFile(readmePath, "utf8");
+  }
+
+  return `# SimpleMDG Dev CLI\n\nGuide file was not found. Run smdg --help to see command help.`;
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#039;");
+}
+
+function inlineMarkdown(value: string): string {
+  return escapeHtml(value)
+    .replace(/`([^`]+)`/g, "<code>$1</code>")
+    .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+}
+
+function markdownToHtml(markdown: string): string {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const htmlLines: string[] = [];
+  let inCodeBlock = false;
+  let codeLines: string[] = [];
+  let inList = false;
+
+  function closeList(): void {
+    if (inList) {
+      htmlLines.push("</ul>");
+      inList = false;
+    }
+  }
+
+  function closeCodeBlock(): void {
+    if (inCodeBlock) {
+      htmlLines.push(`<pre><code>${escapeHtml(codeLines.join("\n"))}</code></pre>`);
+      codeLines = [];
+      inCodeBlock = false;
+    }
+  }
+
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      if (inCodeBlock) {
+        closeCodeBlock();
+      } else {
+        closeList();
+        inCodeBlock = true;
+        codeLines = [];
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeLines.push(line);
+      continue;
+    }
+
+    const trimmedLine = line.trim();
+
+    if (!trimmedLine) {
+      closeList();
+      continue;
+    }
+
+    const headingMatch = /^(#{1,4})\s+(.+)$/.exec(trimmedLine);
+    if (headingMatch) {
+      closeList();
+      const level = headingMatch[1].length;
+      htmlLines.push(`<h${level}>${inlineMarkdown(headingMatch[2])}</h${level}>`);
+      continue;
+    }
+
+    const bulletMatch = /^[-*]\s+(.+)$/.exec(trimmedLine);
+    if (bulletMatch) {
+      if (!inList) {
+        htmlLines.push("<ul>");
+        inList = true;
+      }
+      htmlLines.push(`<li>${inlineMarkdown(bulletMatch[1])}</li>`);
+      continue;
+    }
+
+    closeList();
+    htmlLines.push(`<p>${inlineMarkdown(trimmedLine)}</p>`);
+  }
+
+  closeCodeBlock();
+  closeList();
+
+  return htmlLines.join("\n");
+}
+
+function buildGuideHtml(markdown: string): string {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>SimpleMDG Dev CLI Guide</title>
+  <style>
+    :root { color-scheme: light dark; }
+    body {
+      margin: 0;
+      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      background: #0f172a;
+      color: #e5e7eb;
+      line-height: 1.65;
+    }
+    .layout {
+      max-width: 980px;
+      margin: 0 auto;
+      padding: 40px 24px 80px;
+    }
+    .card {
+      background: #111827;
+      border: 1px solid #334155;
+      border-radius: 18px;
+      padding: 28px;
+      box-shadow: 0 20px 50px rgba(0, 0, 0, 0.35);
+    }
+    h1 { margin-top: 0; font-size: 34px; color: #ffffff; }
+    h2 { margin-top: 36px; padding-top: 22px; border-top: 1px solid #334155; color: #93c5fd; }
+    h3 { color: #bfdbfe; }
+    p, li { color: #d1d5db; }
+    code {
+      background: #1f2937;
+      color: #fbbf24;
+      padding: 2px 6px;
+      border-radius: 6px;
+      font-size: 0.92em;
+    }
+    pre {
+      background: #020617;
+      color: #e5e7eb;
+      padding: 16px;
+      border-radius: 12px;
+      overflow-x: auto;
+      border: 1px solid #1e293b;
+    }
+    pre code { background: transparent; color: inherit; padding: 0; }
+    ul { padding-left: 24px; }
+    .hint {
+      margin-bottom: 18px;
+      padding: 12px 14px;
+      border-radius: 12px;
+      background: #172554;
+      color: #dbeafe;
+      border: 1px solid #1d4ed8;
+    }
+  </style>
+</head>
+<body>
+  <main class="layout">
+    <div class="hint">Local visual guide. Keep this terminal open. Press Ctrl + C to stop the guide server.</div>
+    <article class="card">
+      ${markdownToHtml(markdown)}
+    </article>
+  </main>
+</body>
+</html>`;
+}
+
+function openBrowser(url: string): void {
+  const platform = process.platform;
+
+  if (platform === "win32") {
+    spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+
+  if (platform === "darwin") {
+    spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+
+  spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+}
+
+export async function printUserGuide(): Promise<void> {
+  const markdown = await readGuideMarkdown();
+  console.log(markdown);
+}
+
+export async function openUserGuideInBrowser(port?: string): Promise<void> {
+  const markdown = await readGuideMarkdown();
+  const html = buildGuideHtml(markdown);
+  const requestedPort = port?.trim() ? Number(port.trim()) : 0;
+
+  if (port?.trim() && (!Number.isInteger(requestedPort) || requestedPort < 1 || requestedPort > 65535)) {
+    throw new Error("Guide port must be a number from 1 to 65535");
+  }
+
+  const server = http.createServer((request, response) => {
+    if (request.url === "/" || request.url === "/index.html") {
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      response.end(html);
+      return;
+    }
+
+    response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+    response.end("Not found");
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(requestedPort, "127.0.0.1", () => resolve());
+  });
+
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : requestedPort;
+  const url = `http://127.0.0.1:${actualPort}`;
+
+  console.log(chalk.green(`SimpleMDG Dev CLI guide: ${url}`));
+  console.log(chalk.gray("Press Ctrl + C to stop the guide server."));
+  openBrowser(url);
+}
+
+export async function askRootHelpMode(): Promise<TGuideMode> {
+  const response = await prompts({
+    type: "select",
+    name: "mode",
+    message: "How do you want to view SimpleMDG CLI help?",
+    choices: [
+      { title: "View quick guide in terminal", value: "terminal" },
+      { title: "Open visual guide in browser", value: "web" },
+      { title: "Show command help", value: "commander-help" },
+    ],
+    initial: 0,
+  });
+
+  return (response.mode ?? "commander-help") as TGuideMode;
+}