okengine 0.11.2 → 0.12.0

package/src/console/ui-next/src/features/store/lib/sql-statements.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+import {
+  isSqlWrite,
+  isUnboundedSelect,
+  lineAtOffset,
+  splitSqlStatements,
+  sqlBatchToRun,
+  sqlToRun,
+  statementAtCursor,
+  wrapExplain,
+} from "./sql-statements.ts";
+
+describe("splitSqlStatements", () => {
+  test("splits on semicolons outside strings", () => {
+    const stmts = splitSqlStatements(`SELECT 1; SELECT ';' FROM t;`);
+    expect(stmts.map((s) => s.text)).toEqual(["SELECT 1;", "SELECT ';' FROM t;"]);
+    expect(stmts[0]?.startLine).toBe(1);
+    expect(stmts[1]?.startLine).toBe(1);
+  });
+
+  test("keeps a trailing statement without a semicolon", () => {
+    const stmts = splitSqlStatements("SELECT 1;\nSELECT 2");
+    expect(stmts.map((s) => s.text)).toEqual(["SELECT 1;", "SELECT 2"]);
+    expect(stmts[1]?.startLine).toBe(2);
+  });
+
+  test("ignores empty chunks", () => {
+    expect(splitSqlStatements("   ;\n\n")).toEqual([]);
+  });
+});
+
+describe("sqlToRun", () => {
+  const sql = "SELECT 1;\nSELECT 2;";
+
+  test("uses a non-empty selection", () => {
+    expect(sqlToRun(sql, 0, 9)).toBe("SELECT 1;");
+  });
+
+  test("uses the statement at the caret", () => {
+    expect(sqlToRun(sql, 12, 12)).toBe("SELECT 2;");
+  });
+});
+
+describe("statementAtCursor", () => {
+  test("returns the last statement when the caret is past the end", () => {
+    const sql = "SELECT 1;";
+    expect(statementAtCursor(sql, 99)?.text).toBe("SELECT 1;");
+  });
+});
+
+describe("sqlBatchToRun", () => {
+  const sql = "SELECT 1;\nINSERT INTO t VALUES (1);\nSELECT 2;";
+
+  test("current uses the caret statement", () => {
+    expect(sqlBatchToRun(sql, 0, 0, "current")).toEqual(["SELECT 1;"]);
+  });
+
+  test("selection splits into statements", () => {
+    expect(sqlBatchToRun(sql, 0, sql.length, "current")).toEqual([
+      "SELECT 1;",
+      "INSERT INTO t VALUES (1);",
+      "SELECT 2;",
+    ]);
+  });
+
+  test("all returns every statement", () => {
+    expect(sqlBatchToRun(sql, 0, 0, "all")).toEqual([
+      "SELECT 1;",
+      "INSERT INTO t VALUES (1);",
+      "SELECT 2;",
+    ]);
+  });
+});
+
+describe("wrapExplain", () => {
+  test("prefixes EXPLAIN and skips a second wrap", () => {
+    expect(wrapExplain("SELECT 1;", false)).toBe("EXPLAIN SELECT 1");
+    expect(wrapExplain("SELECT 1", true)).toBe("EXPLAIN ANALYZE SELECT 1");
+    expect(wrapExplain("EXPLAIN SELECT 1", false)).toBe("EXPLAIN SELECT 1");
+  });
+});
+
+describe("isSqlWrite", () => {
+  test("flags DML and DDL heads", () => {
+    expect(isSqlWrite("INSERT INTO t VALUES (1)")).toBe(true);
+    expect(isSqlWrite("UPDATE t SET n = 1")).toBe(true);
+    expect(isSqlWrite("DELETE FROM t WHERE id = 'a'")).toBe(true);
+    expect(isSqlWrite("CREATE TABLE t (id text)")).toBe(true);
+    expect(isSqlWrite("DROP TABLE t")).toBe(true);
+    expect(isSqlWrite("SELECT * FROM t")).toBe(false);
+    expect(isSqlWrite("EXPLAIN SELECT 1")).toBe(false);
+    expect(isSqlWrite("EXPLAIN ANALYZE SELECT 1")).toBe(true);
+    expect(isSqlWrite("GRANT SELECT ON t TO public")).toBe(true);
+    expect(isSqlWrite("ANALYZE t")).toBe(true);
+  });
+});
+
+describe("isUnboundedSelect", () => {
+  test("flags SELECT / WITH without LIMIT", () => {
+    expect(isUnboundedSelect("SELECT * FROM t")).toBe(true);
+    expect(isUnboundedSelect("with x as (select 1) select * from x")).toBe(true);
+    expect(isUnboundedSelect("SELECT * FROM t LIMIT 10")).toBe(false);
+    expect(isUnboundedSelect("SELECT 'limit' FROM t")).toBe(true);
+    expect(isUnboundedSelect("INSERT INTO t VALUES (1)")).toBe(false);
+  });
+});
+
+describe("lineAtOffset", () => {
+  test("counts newlines", () => {
+    expect(lineAtOffset("a\nb\nc", 0)).toBe(1);
+    expect(lineAtOffset("a\nb\nc", 2)).toBe(2);
+    expect(lineAtOffset("a\nb\nc", 4)).toBe(3);
+  });
+});

package/src/console/ui-next/src/features/store/lib/sql-statements.ts

@@ -0,0 +1,205 @@
+/**
+ * Statement bounds for the SQL query console (run current / selection).
+ */
+
+import { splitSqlPreservingStrings } from "./sql-format.ts";
+
+/** One executable statement in a buffer. */
+export type SqlStatement = {
+  readonly text: string;
+  readonly start: number;
+  readonly end: number;
+  /** 1-based line of the first non-whitespace character. */
+  readonly startLine: number;
+};
+
+/**
+ * Split SQL on `;` outside quotes. Trailing text without a semicolon is kept.
+ *
+ * @param sql - Editor buffer
+ */
+export function splitSqlStatements(sql: string): readonly SqlStatement[] {
+  const parts = splitSqlPreservingStrings(sql);
+  const out: SqlStatement[] = [];
+  let stmtStart = 0;
+  let offset = 0;
+  for (const part of parts) {
+    if (!part.quoted) {
+      for (let i = 0; i < part.text.length; i += 1) {
+        if (part.text[i] !== ";") continue;
+        const end = offset + i + 1;
+        pushStatement(out, sql, stmtStart, end);
+        stmtStart = end;
+      }
+    }
+    offset += part.text.length;
+  }
+  pushStatement(out, sql, stmtStart, sql.length);
+  return out;
+}
+
+/**
+ * Statement that contains `cursor` (or the last one before it).
+ *
+ * @param sql - Editor buffer
+ * @param cursor - Caret offset
+ */
+export function statementAtCursor(sql: string, cursor: number): SqlStatement | null {
+  const statements = splitSqlStatements(sql);
+  if (statements.length === 0) return null;
+  const clamped = Math.max(0, Math.min(cursor, sql.length));
+  for (const stmt of statements) {
+    if (clamped >= stmt.start && clamped <= stmt.end) return stmt;
+  }
+  return statements[statements.length - 1] ?? null;
+}
+
+/**
+ * Text to execute: the selection when non-empty, otherwise the statement at the caret.
+ *
+ * @param sql - Editor buffer
+ * @param selectionStart - Selection anchor
+ * @param selectionEnd - Selection focus
+ */
+export function sqlToRun(sql: string, selectionStart: number, selectionEnd: number): string {
+  const from = Math.min(selectionStart, selectionEnd);
+  const to = Math.max(selectionStart, selectionEnd);
+  if (to > from) {
+    const selected = sql.slice(from, to).trim();
+    if (selected.length > 0) return selected;
+  }
+  return statementAtCursor(sql, from)?.text ?? sql.trim();
+}
+
+/**
+ * Statements to execute for current / selection / whole script.
+ *
+ * @param sql - Editor buffer
+ * @param selectionStart - Selection anchor
+ * @param selectionEnd - Selection focus
+ * @param mode - Current statement, selection, or all
+ */
+export function sqlBatchToRun(
+  sql: string,
+  selectionStart: number,
+  selectionEnd: number,
+  mode: "current" | "all",
+): readonly string[] {
+  if (mode === "all") {
+    return splitSqlStatements(sql).map((stmt) => stmt.text);
+  }
+  const from = Math.min(selectionStart, selectionEnd);
+  const to = Math.max(selectionStart, selectionEnd);
+  if (to > from) {
+    const selected = sql.slice(from, to);
+    const parts = splitSqlStatements(selected).map((stmt) => stmt.text);
+    if (parts.length > 0) return parts;
+  }
+  const one = statementAtCursor(sql, from)?.text ?? sql.trim();
+  return one.length > 0 ? [one] : [];
+}
+
+/**
+ * Prefix a statement with `EXPLAIN` or `EXPLAIN ANALYZE`.
+ *
+ * @param sql - One statement
+ * @param analyze - When true, `EXPLAIN ANALYZE`
+ */
+export function wrapExplain(sql: string, analyze: boolean): string {
+  const trimmed = sql.trim().replace(/;+\s*$/, "");
+  if (trimmed.length === 0) return trimmed;
+  if (/^EXPLAIN\b/i.test(trimmed)) return trimmed;
+  return analyze ? `EXPLAIN ANALYZE ${trimmed}` : `EXPLAIN ${trimmed}`;
+}
+
+/**
+ * True when the statement mutates the store (DML / DDL).
+ * Keep heads in sync with `runStoreSql` in `src/console/server/store.ts`.
+ *
+ * @param sql - One statement
+ */
+const WRITE_HEADS = new Set([
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "DROP",
+  "ALTER",
+  "CREATE",
+  "TRUNCATE",
+  "REPLACE",
+  "GRANT",
+  "REVOKE",
+  "VACUUM",
+  "COMMENT",
+  "COPY",
+  "CALL",
+  "REFRESH",
+  "MERGE",
+]);
+
+export function isSqlWrite(sql: string): boolean {
+  const trimmed = sql.trim().replace(/;+\s*$/, "");
+  const head = leadingKeyword(trimmed);
+  if (head === "EXPLAIN") return /\bANALYZE\b/i.test(trimmed);
+  if (head === "ANALYZE") return true;
+  return WRITE_HEADS.has(head);
+}
+
+/**
+ * True when the statement is a SELECT (or WITH) that has no LIMIT.
+ *
+ * @param sql - One statement
+ */
+export function isUnboundedSelect(sql: string): boolean {
+  const trimmed = sql.trim().replace(/;+\s*$/, "");
+  if (trimmed.length === 0) return false;
+  const head = leadingKeyword(trimmed);
+  if (head !== "SELECT" && head !== "WITH") return false;
+  for (const part of splitSqlPreservingStrings(trimmed)) {
+    if (part.quoted) continue;
+    if (/\bLIMIT\b/i.test(part.text)) return false;
+  }
+  return true;
+}
+
+/**
+ * 1-based line number for an offset.
+ *
+ * @param text - Source
+ * @param offset - Character offset
+ */
+export function lineAtOffset(text: string, offset: number): number {
+  const clamped = Math.max(0, Math.min(offset, text.length));
+  let line = 1;
+  for (let i = 0; i < clamped; i += 1) {
+    if (text[i] === "\n") line += 1;
+  }
+  return line;
+}
+
+function pushStatement(out: SqlStatement[], sql: string, start: number, end: number): void {
+  const raw = sql.slice(start, end);
+  if (raw.replace(/[;\s]/g, "").length === 0) return;
+  const first = start + (raw.match(/^\s*/)?.[0]?.length ?? 0);
+  out.push({
+    text: raw.trim(),
+    start,
+    end,
+    startLine: lineAtOffset(sql, first),
+  });
+}
+
+/**
+ * First keyword of a statement (`SELECT`, `CREATE`, …).
+ *
+ * @param sql - One statement
+ */
+export function sqlStatementLabel(sql: string): string {
+  const head = leadingKeyword(sql.trim().replace(/;+\s*$/, ""));
+  return head.length > 0 ? head : "SQL";
+}
+
+function leadingKeyword(sql: string): string {
+  const match = /^([A-Za-z]+)/.exec(sql);
+  return match?.[1]?.toUpperCase() ?? "";
+}

package/src/console/ui-next/src/features/store/lib/sql-trigger.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildCreateTriggerSql,
+  DEFAULT_CREATE_TRIGGER_SQL,
+  isCreateTriggerSql,
+  isSafeTriggerWhen,
+} from "./sql-trigger.ts";
+
+describe("isCreateTriggerSql", () => {
+  test("accepts the default template and OR REPLACE", () => {
+    expect(isCreateTriggerSql(DEFAULT_CREATE_TRIGGER_SQL)).toBe(true);
+    expect(
+      isCreateTriggerSql(
+        "create or replace trigger t after insert on bookings execute function f()",
+      ),
+    ).toBe(true);
+  });
+
+  test("rejects other statements", () => {
+    expect(isCreateTriggerSql("SELECT 1")).toBe(false);
+    expect(isCreateTriggerSql("CREATE FUNCTION f() RETURNS void AS $$ $$")).toBe(false);
+    expect(isCreateTriggerSql("")).toBe(false);
+  });
+});
+
+describe("buildCreateTriggerSql", () => {
+  test("pretty-prints AFTER INSERT", () => {
+    expect(
+      buildCreateTriggerSql({
+        name: "after_insert",
+        table: "comments",
+        timing: "AFTER",
+        events: ["INSERT"],
+        level: "ROW",
+        functionName: "notify_comment",
+      }),
+    ).toBe(
+      [
+        'CREATE TRIGGER "after_insert"',
+        "  AFTER INSERT",
+        '  ON "comments"',
+        "  FOR EACH ROW",
+        '  EXECUTE FUNCTION "notify_comment"();',
+      ].join("\n"),
+    );
+  });
+
+  test("joins events, WHEN, schema function, and OR REPLACE", () => {
+    expect(
+      buildCreateTriggerSql({
+        name: "after_write",
+        table: "bookings",
+        timing: "AFTER",
+        events: ["INSERT", "UPDATE", "DELETE"],
+        level: "ROW",
+        functionName: "public.touch",
+        when: "NEW.id IS NOT NULL",
+        orReplace: true,
+      }),
+    ).toBe(
+      [
+        'CREATE OR REPLACE TRIGGER "after_write"',
+        "  AFTER INSERT OR UPDATE OR DELETE",
+        '  ON "bookings"',
+        "  FOR EACH ROW",
+        "  WHEN (NEW.id IS NOT NULL)",
+        '  EXECUTE FUNCTION "public"."touch"();',
+      ].join("\n"),
+    );
+  });
+
+  test("adds CONSTRAINT, UPDATE OF, REFERENCING, and function args", () => {
+    expect(
+      buildCreateTriggerSql({
+        name: "after_update",
+        table: "bookings",
+        timing: "AFTER",
+        events: ["UPDATE"],
+        level: "STATEMENT",
+        functionName: "touch",
+        constraint: true,
+        defer: "deferred",
+        updateOf: "status",
+        referencingNew: "new_rows",
+        functionArgs: "'ping'",
+      }),
+    ).toBe(
+      [
+        'CREATE CONSTRAINT TRIGGER "after_update"',
+        "  AFTER UPDATE OF status",
+        '  ON "bookings"',
+        "  DEFERRABLE INITIALLY DEFERRED",
+        '  REFERENCING NEW TABLE AS "new_rows"',
+        "  FOR EACH STATEMENT",
+        "  EXECUTE FUNCTION \"touch\"('ping');",
+      ].join("\n"),
+    );
+  });
+
+  test("omits unsafe WHEN", () => {
+    const sql = buildCreateTriggerSql({
+      name: "t",
+      table: "bookings",
+      timing: "BEFORE",
+      events: ["DELETE"],
+      level: "ROW",
+      functionName: "f",
+      when: "true; DROP TABLE bookings",
+    });
+    expect(sql).not.toContain("WHEN");
+    expect(sql).not.toContain("DROP TABLE");
+  });
+});
+
+describe("isSafeTriggerWhen", () => {
+  test("allows a boolean expression", () => {
+    expect(isSafeTriggerWhen("NEW.status = 'open'")).toBe(true);
+  });
+
+  test("rejects stacking and comments", () => {
+    expect(isSafeTriggerWhen("true; SELECT 1")).toBe(false);
+    expect(isSafeTriggerWhen("true -- x")).toBe(false);
+    expect(isSafeTriggerWhen("true /* x */")).toBe(false);
+  });
+});

package/src/console/ui-next/src/features/store/lib/sql-trigger.ts

@@ -0,0 +1,210 @@
+/**
+ * CREATE TRIGGER starter, templates, and preview SQL for the Triggers sheet.
+ */
+
+import { quotePgIdent } from "../../../../../../drivers/pg-rls.ts";
+
+/** When the trigger fires. */
+export type SqlTriggerTiming = "BEFORE" | "AFTER" | "INSTEAD OF";
+
+/** Event the trigger listens for. */
+export type SqlTriggerEvent = "INSERT" | "UPDATE" | "DELETE" | "TRUNCATE";
+
+/** Row vs statement trigger. */
+export type SqlTriggerLevel = "ROW" | "STATEMENT";
+
+/** Constraint trigger deferral (only with `CONSTRAINT`). */
+export type SqlTriggerDefer = "immediate" | "deferred";
+
+/** Fields for `CREATE TRIGGER`. */
+export type SqlTriggerSpec = {
+  readonly name: string;
+  readonly table: string;
+  readonly timing: SqlTriggerTiming;
+  readonly events: readonly SqlTriggerEvent[];
+  readonly level: SqlTriggerLevel;
+  readonly functionName: string;
+  readonly when?: string;
+  readonly orReplace?: boolean;
+  readonly constraint?: boolean;
+  readonly defer?: SqlTriggerDefer;
+  readonly updateOf?: string;
+  readonly referencingOld?: string;
+  readonly referencingNew?: string;
+  readonly functionArgs?: string;
+};
+
+/** One starter template for the New trigger sheet. */
+export type SqlTriggerTemplate = {
+  readonly id: string;
+  readonly title: string;
+  readonly detail: string;
+  readonly timing: SqlTriggerTiming;
+  readonly events: readonly SqlTriggerEvent[];
+  readonly level: SqlTriggerLevel;
+};
+
+/** Common Postgres trigger starters. */
+export const SQL_TRIGGER_TEMPLATES: readonly SqlTriggerTemplate[] = [
+  {
+    id: "after-insert",
+    title: "After insert",
+    detail: "AFTER INSERT for each row — run a function when a row is added.",
+    timing: "AFTER",
+    events: ["INSERT"],
+    level: "ROW",
+  },
+  {
+    id: "after-update",
+    title: "After update",
+    detail: "AFTER UPDATE for each row — react when a row changes.",
+    timing: "AFTER",
+    events: ["UPDATE"],
+    level: "ROW",
+  },
+  {
+    id: "before-delete",
+    title: "Before delete",
+    detail: "BEFORE DELETE for each row — inspect or block a delete.",
+    timing: "BEFORE",
+    events: ["DELETE"],
+    level: "ROW",
+  },
+  {
+    id: "after-write",
+    title: "After write",
+    detail: "AFTER INSERT OR UPDATE OR DELETE — one function for any write.",
+    timing: "AFTER",
+    events: ["INSERT", "UPDATE", "DELETE"],
+    level: "ROW",
+  },
+];
+
+/**
+ * Pretty `CREATE TRIGGER` for the review editor.
+ *
+ * @param spec - Trigger fields
+ */
+export function buildCreateTriggerSql(spec: SqlTriggerSpec): string {
+  const events = formatTriggerEvents(spec.events, spec.updateOf);
+  const replace = spec.orReplace === true ? "OR REPLACE " : "";
+  const constraint = spec.constraint === true ? "CONSTRAINT " : "";
+  const lines = [
+    `CREATE ${replace}${constraint}TRIGGER ${quotePgIdent(spec.name)}`,
+    `  ${spec.timing} ${events}`,
+    `  ON ${quotePgIdent(spec.table)}`,
+  ];
+  if (spec.constraint === true && spec.defer === "deferred") {
+    lines.push("  DEFERRABLE INITIALLY DEFERRED");
+  } else if (spec.constraint === true && spec.defer === "immediate") {
+    lines.push("  DEFERRABLE INITIALLY IMMEDIATE");
+  }
+  const referencing = formatTriggerReferencing(spec.referencingOld, spec.referencingNew);
+  if (referencing !== "") lines.push(`  ${referencing}`);
+  lines.push(`  FOR EACH ${spec.level}`);
+  const when = spec.when?.trim() ?? "";
+  if (when !== "" && isSafeTriggerWhen(when)) {
+    lines.push(`  WHEN (${when})`);
+  }
+  const args =
+    spec.functionArgs !== undefined && isSafeTriggerWhen(spec.functionArgs.trim())
+      ? spec.functionArgs.trim()
+      : "";
+  lines.push(`  EXECUTE FUNCTION ${quoteFunctionName(spec.functionName)}(${args});`);
+  return lines.join("\n");
+}
+
+/** Default body shown in the New trigger sheet. */
+export const DEFAULT_CREATE_TRIGGER_SQL = buildCreateTriggerSql({
+  name: "trigger_name",
+  table: "table_name",
+  timing: "AFTER",
+  events: ["INSERT", "UPDATE", "DELETE"],
+  level: "ROW",
+  functionName: "function_name",
+});
+
+/**
+ * True when the buffer is a CREATE TRIGGER statement (or OR REPLACE / CONSTRAINT).
+ *
+ * @param sql - Editor buffer
+ */
+export function isCreateTriggerSql(sql: string): boolean {
+  return /^\s*CREATE\s+(OR\s+REPLACE\s+)?(CONSTRAINT\s+)?TRIGGER\b/i.test(sql);
+}
+
+/**
+ * True when `expr` is a single WHEN expression (no statement stacking).
+ *
+ * @param expr - WHEN body
+ */
+export function isSafeTriggerWhen(expr: string): boolean {
+  const t = expr.trim();
+  return t.length > 0 && t.length <= 2000 && !/;/.test(t) && !/--/.test(t) && !/\/\*/.test(t);
+}
+
+/**
+ * Count of Advanced trigger knobs that are set.
+ *
+ * @param spec - Trigger fields
+ */
+export function sqlTriggerAdvancedCount(
+  spec: Pick<
+    SqlTriggerSpec,
+    | "constraint"
+    | "defer"
+    | "updateOf"
+    | "referencingOld"
+    | "referencingNew"
+    | "functionArgs"
+    | "events"
+  >,
+): number {
+  return (
+    (spec.constraint === true ? 1 : 0) +
+    (spec.defer !== undefined ? 1 : 0) +
+    (spec.updateOf?.trim() ? 1 : 0) +
+    (spec.referencingOld?.trim() ? 1 : 0) +
+    (spec.referencingNew?.trim() ? 1 : 0) +
+    (spec.functionArgs?.trim() ? 1 : 0) +
+    (spec.events.includes("TRUNCATE") ? 1 : 0)
+  );
+}
+
+function formatTriggerEvents(
+  events: readonly SqlTriggerEvent[],
+  updateOf: string | undefined,
+): string {
+  const list = events.length > 0 ? events : (["INSERT"] as const);
+  const of = updateOf?.trim() ?? "";
+  return list
+    .map((event) => {
+      if (event === "UPDATE" && of !== "" && isSafeTriggerWhen(of)) {
+        return `UPDATE OF ${of}`;
+      }
+      return event;
+    })
+    .join(" OR ");
+}
+
+function formatTriggerReferencing(
+  oldTable: string | undefined,
+  newTable: string | undefined,
+): string {
+  const parts: string[] = [];
+  const oldName = oldTable?.trim() ?? "";
+  const newName = newTable?.trim() ?? "";
+  if (oldName !== "" && isSafeTriggerWhen(oldName)) {
+    parts.push(`OLD TABLE AS ${quotePgIdent(oldName)}`);
+  }
+  if (newName !== "" && isSafeTriggerWhen(newName)) {
+    parts.push(`NEW TABLE AS ${quotePgIdent(newName)}`);
+  }
+  return parts.length > 0 ? `REFERENCING ${parts.join(" ")}` : "";
+}
+
+function quoteFunctionName(raw: string): string {
+  const name = raw.trim().replace(/\(\s*\)$/, "");
+  const parts = (name.length > 0 ? name : "function_name").split(".");
+  return parts.map((part) => quotePgIdent(part)).join(".");
+}