simplemdg-dev-cli 2.4.5 → 2.6.0

package/src/core/db/db-studio-server.ts

@@ -23,7 +23,7 @@ import {
   generateSelectSql,
   looksLikeProduction,
 } from "./db-metadata";
-import type { TResolvedDatabaseConnection, TTableChangeSet } from "./db-types";
+import type { TGridSortState, TResolvedDatabaseConnection, TStudioWorkspaceState, TTableChangeSet } from "./db-types";
 import {
   deleteSavedQuery,
   listSavedQueries,
@@ -32,6 +32,15 @@ import {
 } from "./db-query-files";
 import { deleteRow, insertRow, saveTableChanges, updateRow } from "./db-row";
 import { appendQueryHistory, listQueryHistory } from "./db-query-history";
+import { readWorkspace, writeWorkspace } from "./studio/workspace-cache";
+import { readStudioSettings, writeStudioSettings } from "./studio/studio-settings";
+import {
+  formatSql,
+  generateInsertTemplate,
+  generateTableQuery,
+  generateUpdateTemplate,
+  splitStatements,
+} from "./studio/sql-formatter";
 import {
   detectAppDatabaseServices,
   ensureCloudFoundrySession,
@@ -39,6 +48,7 @@ import {
   importConnectionFromApp,
   listCloudFoundryAppsWithCache,
 } from "./db-btp";
+import { onCacheEvent } from "../cache/smart-cache";
 import type { TDatabaseObjectKind, TDatabaseType } from "./db-types";
 
 export type TStudioServerOptions = {
@@ -200,6 +210,25 @@ export async function startStudioServer(options: TStudioServerOptions = {}): Pro
       return;
     }
 
+    // Server-Sent Events: stream smart-cache background-refresh notifications.
+    if (pathname === "/api/events" && method === "GET") {
+      res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+      });
+      res.write(": connected\n\n");
+      const unsubscribe = onCacheEvent((event) => {
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+      });
+      const keepAlive = setInterval(() => res.write(": ping\n\n"), 25000);
+      req.on("close", () => {
+        clearInterval(keepAlive);
+        unsubscribe();
+      });
+      return;
+    }
+
     // --- Connections ---------------------------------------------------------
     if (pathname === "/api/connections" && method === "GET") {
       sendJson(res, { connections: await listPublicConnections() });
@@ -565,12 +594,91 @@ export async function startStudioServer(options: TStudioServerOptions = {}): Pro
       return;
     }
 
+    // --- Workspace + settings ------------------------------------------------
+    if (pathname === "/api/studio/workspace" && method === "GET") {
+      sendJson(res, { workspace: await readWorkspace() });
+      return;
+    }
+
+    if (pathname === "/api/studio/workspace" && method === "PUT") {
+      const body = await readJsonBody(req);
+      const workspace = await writeWorkspace(body as unknown as TStudioWorkspaceState);
+      sendJson(res, { workspace });
+      return;
+    }
+
+    if (pathname === "/api/studio/settings" && method === "GET") {
+      sendJson(res, { settings: await readStudioSettings() });
+      return;
+    }
+
+    if (pathname === "/api/studio/settings" && method === "PUT") {
+      const body = await readJsonBody(req);
+      const settings = await writeStudioSettings(body);
+      sendJson(res, { settings });
+      return;
+    }
+
+    // --- SQL helpers ---------------------------------------------------------
+    if (pathname === "/api/sql/format" && method === "POST") {
+      const body = await readJsonBody(req);
+      sendJson(res, { sql: formatSql(getString(body, "sql")) });
+      return;
+    }
+
+    if (pathname === "/api/sql/parse-statements" && method === "POST") {
+      const body = await readJsonBody(req);
+      sendJson(res, { statements: splitStatements(getString(body, "sql")) });
+      return;
+    }
+
+    if (pathname === "/api/sql/generate-table-query" && method === "POST") {
+      const body = await readJsonBody(req);
+      const adapter = await pool.getAdapter(getString(body, "connectionId"));
+      const sql = generateTableQuery({
+        type: adapter.type,
+        schema: getString(body, "schema"),
+        table: getString(body, "table"),
+        where: getString(body, "where") || undefined,
+        sort: Array.isArray(body.sort) ? (body.sort as TGridSortState[]) : undefined,
+        limit: getNumber(body, "limit", 100),
+        offset: getNumber(body, "offset", 0),
+      });
+      sendJson(res, { sql });
+      return;
+    }
+
+    if (pathname === "/api/table/generate-sql" && method === "POST") {
+      const body = await readJsonBody(req);
+      const adapter = await pool.getAdapter(getString(body, "connectionId"));
+      const schema = getString(body, "schema");
+      const table = getString(body, "table");
+      const [columns, primaryKey] = await Promise.all([
+        adapter.listColumns(schema, table).catch(() => []),
+        adapter.getPrimaryKey(schema, table).catch(() => ({ columns: [] })),
+      ]);
+      sendJson(res, {
+        select: generateSelectSql(adapter.type, schema, table, getNumber(body, "limit", 100)),
+        count: generateCountSql(adapter.type, schema, table),
+        insert: generateInsertTemplate(adapter.type, schema, table, columns),
+        update: generateUpdateTemplate(adapter.type, schema, table, columns, primaryKey.columns),
+      });
+      return;
+    }
+
     // --- History -------------------------------------------------------------
     if (pathname === "/api/history" && method === "GET") {
       sendJson(res, { history: await listQueryHistory(100) });
       return;
     }
 
+    if (pathname === "/api/history" && method === "DELETE") {
+      const { clearQueryHistory } = await import("./db-query-history");
+      await clearQueryHistory();
+      sendJson(res, { cleared: true });
+      return;
+    }
+
     // --- Export --------------------------------------------------------------
     if (pathname === "/api/export/csv" && method === "POST") {
       const body = await readJsonBody(req);

package/src/core/db/db-studio-styles.ts

@@ -218,4 +218,40 @@ table.grid tr.row-err td{box-shadow:inset 0 0 0 1px var(--red)}
 .toast.ok{border-left-color:var(--green)}.toast.err{border-left-color:var(--red)}.toast.warn{border-left-color:var(--yellow)}
 @keyframes slideup{from{transform:translateY(8px);opacity:0}to{transform:translateY(0);opacity:1}}
 .empty{color:var(--faint);padding:16px;text-align:center}
+mark.hl{background:#facc15;color:#10151f;border-radius:3px;padding:0 1px}
+/* tabs: pin + drag */
+.wtab.pinned{background:#101a2b}
+.wtab.pinned .t-title{max-width:90px}
+.wtab.dragging{opacity:.5}
+.wtab.dragover{box-shadow:inset 2px 0 0 var(--accent)}
+.wtab .pin{color:var(--amber)}
+/* sql preview popover */
+.popover{position:absolute;z-index:55;background:var(--bg-2);border:1px solid var(--border-2);border-radius:10px;box-shadow:0 16px 50px rgba(0,0,0,.5);padding:10px;width:560px;max-width:90vw}
+.popover pre{margin:0;background:#0a1018;border:1px solid var(--border);border-radius:8px;padding:10px;color:#cfe7ff;font-family:Consolas,monospace;font-size:12.5px;white-space:pre-wrap;max-height:240px;overflow:auto}
+/* change summary bar */
+.changebar{display:flex;align-items:center;gap:10px;padding:7px 10px;background:#2a230a;border:1px solid #a16207;border-radius:9px;margin:0 10px 8px;color:#fde68a}
+.changebar .grow{flex:1}
+/* breadcrumb */
+.crumbs{display:flex;align-items:center;gap:6px;padding:6px 10px;color:var(--muted);font-size:12px;border-bottom:1px solid var(--border);background:var(--bg-2)}
+.crumbs a{color:#8fc6ff;cursor:pointer}
+.crumbs .sep{color:var(--faint)}
+/* command palette */
+.palette{position:fixed;top:80px;left:50%;transform:translateX(-50%);width:560px;max-width:92vw;background:var(--bg-2);border:1px solid var(--border-2);border-radius:12px;box-shadow:0 24px 80px rgba(0,0,0,.55);z-index:85;overflow:hidden}
+.palette input{width:100%;background:#0a1018;border:0;border-bottom:1px solid var(--border);padding:13px 15px;color:#fff;font-size:15px}
+.palette .pitems{max-height:50vh;overflow:auto}
+.palette .pitem{padding:9px 14px;cursor:pointer;display:flex;justify-content:space-between;gap:10px}
+.palette .pitem.sel,.palette .pitem:hover{background:var(--accent);color:#fff}
+.palette .pitem .kbd{color:var(--faint);font-size:11px}
+.kbd{font-family:Consolas,monospace;background:var(--chip);border:1px solid var(--border);border-radius:5px;padding:1px 6px;font-size:11px}
+.shorts{display:grid;grid-template-columns:1fr 1fr;gap:6px 20px}
+.shorts .srow{display:flex;justify-content:space-between;gap:10px;padding:3px 0;border-bottom:1px solid var(--border)}
+/* editor gutter */
+.editwrap{display:flex;border:1px solid var(--border);border-radius:8px;overflow:hidden;background:#0a1018}
+.gutter{padding:11px 8px;text-align:right;color:var(--faint);font-family:Consolas,monospace;font-size:13px;line-height:1.5;user-select:none;background:#0c131e;min-width:42px;overflow:hidden}
+.editwrap .editor{border:0;border-radius:0;flex:1;line-height:1.5}
+.ac{position:absolute;z-index:70;background:var(--bg-2);border:1px solid var(--border-2);border-radius:8px;box-shadow:0 12px 40px rgba(0,0,0,.5);max-height:220px;overflow:auto;min-width:220px}
+.ac .aci{padding:6px 11px;cursor:pointer;display:flex;justify-content:space-between;gap:10px}
+.ac .aci.sel,.ac .aci:hover{background:var(--accent);color:#fff}
+.ac .aci .t{color:var(--faint);font-size:11px}
+.toggle{display:flex;align-items:center;gap:8px;padding:6px 0}
 `;

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

@@ -221,6 +221,67 @@ export type TSaveTableChangesResult = {
   rowResults: TSaveRowResult[];
 };
 
+export type TGridSortState = {
+  column: string;
+  direction: "asc" | "desc";
+};
+
+export type TStudioTabType = "welcome" | "sql" | "data-grid" | "metadata" | "query-file" | "history";
+
+export type TStudioTabState = {
+  id: string;
+  type: TStudioTabType;
+  title: string;
+  groupId?: string;
+  pinned?: boolean;
+  dirty?: boolean;
+  connectionId?: string;
+  schema?: string;
+  objectName?: string;
+  objectType?: "table" | "view";
+  sql?: string;
+  filter?: string;
+  pageSize?: number;
+  pageIndex?: number;
+  sort?: TGridSortState[];
+  openedAt: string;
+  updatedAt: string;
+};
+
+export type TStudioTabGroup = {
+  id: string;
+  name: string;
+  color: string;
+  collapsed?: boolean;
+};
+
+export type TStudioLayoutState = {
+  sidebarWidth?: number;
+  readOnly?: boolean;
+};
+
+export type TStudioWorkspaceState = {
+  version: number;
+  activeTabId?: string;
+  tabs: TStudioTabState[];
+  tabGroups: TStudioTabGroup[];
+  layout: TStudioLayoutState;
+  updatedAt: string;
+};
+
+export type TStudioSettings = {
+  restoreWorkspace: boolean;
+  defaultRowLimit: number;
+  defaultSchema?: string;
+  readOnlyByDefault: boolean;
+  queryTimeoutMs: number;
+  autoFormatGeneratedSql: boolean;
+  autoSaveDelayMs: number;
+  maxHistoryItems: number;
+  showProductionWarning: boolean;
+  theme: string;
+};
+
 export interface IDatabaseAdapter {
   readonly type: TDatabaseType;
   connect(): Promise<void>;

package/src/core/db/studio/sql-formatter.ts

@@ -0,0 +1,139 @@
+import { buildQualifiedName, quoteIdentifier } from "../db-metadata";
+import type { TDatabaseColumn, TDatabaseType, TGridSortState } from "../db-types";
+
+const CLAUSE_KEYWORDS = [
+  "select", "from", "where", "group by", "having", "order by", "limit", "offset",
+  "union all", "union", "left join", "right join", "inner join", "full join", "join", "on",
+  "insert into", "values", "update", "set", "delete from", "create table", "alter table",
+];
+
+/** Lightweight SQL pretty printer: uppercases clause keywords and breaks lines. */
+export function formatSql(sql: string): string {
+  let text = sql.replace(/\s+/g, " ").trim();
+
+  for (const keyword of CLAUSE_KEYWORDS) {
+    const pattern = new RegExp(`\\s*\\b${keyword.replace(/ /g, "\\s+")}\\b\\s*`, "gi");
+    text = text.replace(pattern, (match) => {
+      const upper = keyword.toUpperCase();
+      const isJoinOrOn = /join|^on$/i.test(keyword);
+      return (isJoinOrOn ? "\n  " : "\n") + upper + " ";
+    });
+  }
+
+  return text.replace(/\n\s*\n/g, "\n").replace(/[ \t]+\n/g, "\n").trim();
+}
+
+export type TStatementRange = { sql: string; start: number; end: number };
+
+/** Split SQL into statements on `;`, ignoring semicolons inside strings/comments. */
+export function splitStatementRanges(sql: string): TStatementRange[] {
+  const ranges: TStatementRange[] = [];
+  let buffer = "";
+  let bufferStart = -1;
+  let inString = false;
+  let quote = "";
+  let inLine = false;
+  let inBlock = false;
+
+  const push = (endIndex: number): void => {
+    if (buffer.trim()) {
+      ranges.push({ sql: buffer.trim(), start: bufferStart, end: endIndex });
+    }
+    buffer = "";
+    bufferStart = -1;
+  };
+
+  for (let i = 0; i < sql.length; i += 1) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+
+    if (bufferStart === -1 && !/\s/.test(ch)) {
+      bufferStart = i;
+    }
+
+    if (inLine) {
+      buffer += ch;
+      if (ch === "\n") inLine = false;
+      continue;
+    }
+    if (inBlock) {
+      buffer += ch;
+      if (ch === "*" && next === "/") { buffer += next; i += 1; inBlock = false; }
+      continue;
+    }
+    if (inString) {
+      buffer += ch;
+      if (ch === quote) inString = false;
+      continue;
+    }
+    if (ch === "-" && next === "-") { inLine = true; buffer += ch; continue; }
+    if (ch === "/" && next === "*") { inBlock = true; buffer += ch; continue; }
+    if (ch === "'" || ch === '"') { inString = true; quote = ch; buffer += ch; continue; }
+    if (ch === ";") { push(i); continue; }
+    buffer += ch;
+  }
+
+  push(sql.length);
+  return ranges;
+}
+
+export function splitStatements(sql: string): string[] {
+  return splitStatementRanges(sql).map((range) => range.sql);
+}
+
+/** The statement that contains the given cursor offset (for "Run current statement"). */
+export function statementAtOffset(sql: string, offset: number): string {
+  const ranges = splitStatementRanges(sql);
+  const hit = ranges.find((range) => offset >= range.start && offset <= range.end + 1);
+  return (hit ?? ranges[ranges.length - 1])?.sql ?? sql.trim();
+}
+
+export type TGenerateTableQueryInput = {
+  type: TDatabaseType;
+  schema: string;
+  table: string;
+  where?: string;
+  sort?: TGridSortState[];
+  limit?: number;
+  offset?: number;
+};
+
+export function generateTableQuery(input: TGenerateTableQueryInput): string {
+  const qualified = buildQualifiedName(input.type, input.schema, input.table);
+  const lines = ["SELECT *", `FROM ${qualified}`];
+
+  if (input.where && input.where.trim()) {
+    lines.push(`WHERE ${input.where.trim()}`);
+  }
+
+  if (input.sort && input.sort.length > 0) {
+    const order = input.sort
+      .map((sort) => `${quoteIdentifier(input.type, sort.column)} ${sort.direction === "desc" ? "DESC" : "ASC"}`)
+      .join(", ");
+    lines.push(`ORDER BY ${order}`);
+  }
+
+  if (input.limit && input.limit > 0) {
+    lines.push(`LIMIT ${input.limit}`);
+    lines.push(`OFFSET ${input.offset ?? 0}`);
+  }
+
+  return `${lines.join("\n")};`;
+}
+
+export function generateInsertTemplate(type: TDatabaseType, schema: string, table: string, columns: TDatabaseColumn[]): string {
+  const cols = columns.length > 0 ? columns : [{ name: "column1" } as TDatabaseColumn, { name: "column2" } as TDatabaseColumn];
+  const colNames = cols.map((column) => quoteIdentifier(type, column.name));
+  const placeholders = cols.map((column) => `<${column.name}>`);
+  return `INSERT INTO ${buildQualifiedName(type, schema, table)} (\n  ${colNames.join(", ")}\n) VALUES (\n  ${placeholders.join(", ")}\n);`;
+}
+
+export function generateUpdateTemplate(type: TDatabaseType, schema: string, table: string, columns: TDatabaseColumn[], primaryKey: string[]): string {
+  const keyCols = primaryKey.length > 0 ? primaryKey : columns.slice(0, 1).map((column) => column.name);
+  const setCols = columns.filter((column) => !keyCols.includes(column.name));
+  const setClause = (setCols.length > 0 ? setCols : columns)
+    .map((column) => `${quoteIdentifier(type, column.name)} = <${column.name}>`)
+    .join(",\n  ");
+  const whereClause = keyCols.map((column) => `${quoteIdentifier(type, column)} = <${column}>`).join("\n  AND ");
+  return `UPDATE ${buildQualifiedName(type, schema, table)}\nSET\n  ${setClause}\nWHERE\n  ${whereClause};`;
+}

package/src/core/db/studio/studio-settings.ts

@@ -0,0 +1,36 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import type { TStudioSettings } from "../db-types";
+
+const SETTINGS_PATH = path.join(os.homedir(), ".simplemdg", "db-studio-settings.json");
+
+export const DEFAULT_SETTINGS: TStudioSettings = {
+  restoreWorkspace: true,
+  defaultRowLimit: 100,
+  defaultSchema: undefined,
+  readOnlyByDefault: false,
+  queryTimeoutMs: 30000,
+  autoFormatGeneratedSql: true,
+  autoSaveDelayMs: 500,
+  maxHistoryItems: 300,
+  showProductionWarning: true,
+  theme: "dark",
+};
+
+export async function readStudioSettings(): Promise<TStudioSettings> {
+  if (!(await fs.pathExists(SETTINGS_PATH))) {
+    return { ...DEFAULT_SETTINGS };
+  }
+
+  const parsed = await fs.readJson(SETTINGS_PATH).catch(() => ({})) as Partial<TStudioSettings>;
+  return { ...DEFAULT_SETTINGS, ...parsed };
+}
+
+export async function writeStudioSettings(patch: Partial<TStudioSettings>): Promise<TStudioSettings> {
+  const current = await readStudioSettings();
+  const next: TStudioSettings = { ...current, ...patch };
+  await fs.ensureDir(path.dirname(SETTINGS_PATH));
+  await fs.writeJson(SETTINGS_PATH, next, { spaces: 2 });
+  return next;
+}

package/src/core/db/studio/workspace-cache.ts

@@ -0,0 +1,51 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import type { TStudioWorkspaceState } from "../db-types";
+
+const WORKSPACE_PATH = path.join(os.homedir(), ".simplemdg", "db-studio-workspace.json");
+const WORKSPACE_VERSION = 1;
+
+const EMPTY_WORKSPACE: TStudioWorkspaceState = {
+  version: WORKSPACE_VERSION,
+  activeTabId: undefined,
+  tabs: [],
+  tabGroups: [],
+  layout: {},
+  updatedAt: new Date(0).toISOString(),
+};
+
+export async function readWorkspace(): Promise<TStudioWorkspaceState> {
+  if (!(await fs.pathExists(WORKSPACE_PATH))) {
+    return { ...EMPTY_WORKSPACE };
+  }
+
+  const parsed = await fs.readJson(WORKSPACE_PATH).catch(() => undefined) as Partial<TStudioWorkspaceState> | undefined;
+
+  if (!parsed || !Array.isArray(parsed.tabs)) {
+    return { ...EMPTY_WORKSPACE };
+  }
+
+  return {
+    version: WORKSPACE_VERSION,
+    activeTabId: parsed.activeTabId,
+    tabs: parsed.tabs,
+    tabGroups: Array.isArray(parsed.tabGroups) ? parsed.tabGroups : [],
+    layout: parsed.layout ?? {},
+    updatedAt: parsed.updatedAt ?? new Date().toISOString(),
+  };
+}
+
+export async function writeWorkspace(state: TStudioWorkspaceState): Promise<TStudioWorkspaceState> {
+  const next: TStudioWorkspaceState = {
+    version: WORKSPACE_VERSION,
+    activeTabId: state.activeTabId,
+    tabs: Array.isArray(state.tabs) ? state.tabs : [],
+    tabGroups: Array.isArray(state.tabGroups) ? state.tabGroups : [],
+    layout: state.layout ?? {},
+    updatedAt: new Date().toISOString(),
+  };
+  await fs.ensureDir(path.dirname(WORKSPACE_PATH));
+  await fs.writeJson(WORKSPACE_PATH, next, { spaces: 2 });
+  return next;
+}

package/src/index.ts

@@ -23,6 +23,7 @@ import { registerCloudFoundryCommands } from "./commands/cf.command";
 import { registerCdsCommands } from "./commands/cds.command";
 import { registerNpmrcCommands } from "./commands/npmrc.command";
 import { registerGitLabCommands } from "./commands/gitlab.command";
+import { registerCacheCommands } from "./commands/cache.command";
 import { enableInteractiveNavigation, runGroupNavigator } from "./core/navigator";
 import type { TInstallCommandOptions, TKeyValueMap } from "./types-local";
 
@@ -319,7 +320,7 @@ async function runInstallCommand(options: TInstallCommandOptions): Promise<void>
   process.exitCode = installResult.exitCode;
 }
 
-program.name("simplemdg").description("SimpleMDG local development helper").version("2.4.0");
+program.name("simplemdg").description("SimpleMDG local development helper").version("2.6.0");
 
 
 program
@@ -418,6 +419,7 @@ registerCloudFoundryCommands(program);
 registerCdsCommands(program);
 registerNpmrcCommands(program);
 registerGitLabCommands(program);
+registerCacheCommands(program);
 
 // Turn every group command (cf, cf db, cds, npmrc, gitlab, ...) into an
 // interactive menu so a partial command like `smdg cf` or `smdg cf db` lists