tablewalk 0.0.1

package/dist/client/sqlcomplete.js

@@ -0,0 +1,163 @@
+/**
+ * Completion for the SQL editor.
+ *
+ * The query language's completer knows the grammar it is completing, because
+ * tablewalk wrote that grammar. SQL is somebody else's language and this is not
+ * a parser for it — writing one to power a dropdown would be a large amount of
+ * code that is wrong in a different way for each dialect.
+ *
+ * What it does instead is answer two questions from the text to the left of the
+ * caret: **what is in scope**, and **what kind of thing goes here**. Both are
+ * answerable with a scan, and both degrade in a way that costs the reader
+ * nothing — a wrong guess offers a list they ignore, where a parser that
+ * refused to guess would offer nothing at all.
+ *
+ * The scope question is answered by finding `FROM x`, `JOIN y AS b` and their
+ * aliases anywhere in the statement, not only before the caret: people write
+ * `SELECT ` and then the columns they want, and at that moment the tables are
+ * all to the *right* of where they are typing. A completer that only looked
+ * backwards would be silent at exactly the moment it is most wanted.
+ */
+import { findTable, state } from './core.js';
+
+/* Keywords offered as a last resort, in the order they occur in a statement
+   rather than alphabetically — the point of the list is to suggest what comes
+   next, and `WHERE` is a likelier next word than `ALL`. */
+const KEYWORDS = [
+  'SELECT', 'FROM', 'WHERE', 'GROUP BY', 'HAVING', 'ORDER BY', 'LIMIT', 'OFFSET',
+  'JOIN', 'LEFT JOIN', 'INNER JOIN', 'ON', 'AS', 'AND', 'OR', 'NOT', 'IN', 'LIKE',
+  'IS NULL', 'IS NOT NULL', 'BETWEEN', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END',
+  'DISTINCT', 'COUNT(', 'SUM(', 'AVG(', 'MIN(', 'MAX(', 'COALESCE(', 'WITH', 'UNION',
+  'ASC', 'DESC', 'EXISTS',
+];
+
+/** Words after which a table name is what comes next. */
+const EXPECTS_TABLE = /\b(from|join|update|into|table)\s+(\w*)$/i;
+
+/** Words after which a column name is what comes next. */
+const EXPECTS_COLUMN =
+  /\b(select|where|on|and|or|by|having|set|distinct|,|\(|=|<|>|<=|>=|!=|<>|\+|-)\s*(\w*)$/i;
+
+/**
+ * Tables named in the statement, by the name they are referred to.
+ *
+ * Both directions: the alias if there is one, and the table's own name, since
+ * `FROM customer` makes `customer.id` valid too. Matching is deliberately loose
+ * about the shape of what follows — `AS` optional, a comma or newline ending
+ * it — because the alternative is a parser.
+ */
+export function scopeOf(text) {
+  const scope = new Map();
+  const pattern = /\b(?:from|join|update|into)\s+([A-Za-z_][\w.$]*)(?:\s+(?:as\s+)?([A-Za-z_]\w*))?/gi;
+
+  for (const match of text.matchAll(pattern)) {
+    const [, name, alias] = match;
+    // `FROM customer WHERE` — `WHERE` is not an alias, and neither is any other
+    // word that can legally follow a table name.
+    const isKeyword = alias && /^(where|join|left|right|inner|outer|cross|on|group|order|limit|having|union|set|values|using|and|or)$/i.test(alias);
+    const table = findTable(name) ?? state.schema?.tables.find((t) => t.name === name);
+    if (!table) continue;
+    scope.set(table.name, table);
+    scope.set(table.id, table);
+    if (alias && !isKeyword) scope.set(alias, table);
+  }
+  return scope;
+}
+
+/** The word being typed, and where it starts. Splits on SQL's punctuation. */
+export function tokenAt(text, caret) {
+  const before = text.slice(0, caret);
+  const start = Math.max(0, ...[' ', '\n', '\t', ',', '(', ')', '=', '<', '>', '+', '-', '*', '/', ';']
+    .map((c) => before.lastIndexOf(c) + 1));
+  return { word: before.slice(start), start };
+}
+
+const columnItem = (table, column, detail) => ({
+  kind: column.primaryKey ? 'key' : column.references ? 'ref' : 'column',
+  label: column.name,
+  value: column.name,
+  detail: detail ?? `${table.name} · ${column.type}`,
+});
+
+/**
+ * What could come next, given where the caret is.
+ *
+ * Ordering within the list matters more than the list itself: the first entry
+ * is what Tab accepts, so it has to be the likeliest thing rather than the
+ * alphabetically first. Columns of tables actually in the statement come before
+ * every other table's columns, and keywords come last — a keyword is always
+ * *possible*, which is exactly why it is never the best guess.
+ */
+export function sqlSuggestions(text, caret) {
+  if (!state.schema) return [];
+  const { word } = tokenAt(text, caret);
+  const before = text.slice(0, caret);
+  const scope = scopeOf(text);
+  const matches = (name) => name.toLowerCase().startsWith(word.toLowerCase());
+
+  /* `alias.` — the one case with a definite answer. Nothing else can follow a
+     qualified name, so nothing else is offered. */
+  const qualified = /([A-Za-z_]\w*)\.(\w*)$/.exec(before);
+  if (qualified) {
+    const [, prefix, partial] = qualified;
+    const table = scope.get(prefix) ?? findTable(prefix) ?? state.schema.tables.find((t) => t.name === prefix);
+    if (!table) return [];
+    return table.columns
+      .filter((c) => c.name.toLowerCase().startsWith(partial.toLowerCase()))
+      .map((c) => ({ ...columnItem(table, c), value: c.name }));
+  }
+
+  const out = [];
+  const tableItem = (t) => ({
+    kind: t.isView ? 'view' : 'table',
+    label: t.name,
+    value: t.id,
+    detail: `${t.columns.length} column${t.columns.length === 1 ? '' : 's'}`,
+  });
+
+  if (EXPECTS_TABLE.test(before)) {
+    // After FROM, a table is the only sensible suggestion, so nothing dilutes it.
+    return state.schema.tables.filter((t) => matches(t.name) || matches(t.id)).map(tableItem);
+  }
+
+  if (EXPECTS_COLUMN.test(before) || word) {
+    for (const table of new Set(scope.values())) {
+      for (const column of table.columns) {
+        if (matches(column.name)) out.push(columnItem(table, column));
+      }
+    }
+    /* Aliases and table names themselves, so `c.` is reachable by typing `c`
+       and accepting rather than by remembering it. */
+    for (const [name, table] of scope) {
+      if (matches(name) && name !== table.name) {
+        out.push({ kind: 'alias', label: name, value: name, detail: `alias for ${table.name}` });
+      }
+    }
+    /* Every other table's columns, once the statement's own are exhausted. A
+       column typed before its FROM clause exists is a real way people write
+       SQL, and offering nothing there is worse than offering a long list. */
+    if (!out.length) {
+      for (const table of state.schema.tables) {
+        if (scope.has(table.name)) continue;
+        for (const column of table.columns) {
+          if (matches(column.name)) out.push(columnItem(table, column, `${table.name} · not in this statement`));
+        }
+      }
+    }
+  }
+
+  if (!word || EXPECTS_TABLE.test(before) === false) {
+    for (const keyword of KEYWORDS) {
+      if (matches(keyword)) {
+        out.push({ kind: 'keyword', label: keyword, value: keyword, detail: '' });
+      }
+    }
+  }
+
+  // Tables last among the non-keywords: a bare word is more often a column.
+  for (const table of state.schema.tables) {
+    if (matches(table.name) && !scope.has(table.name)) out.push(tableItem(table));
+  }
+
+  return out;
+}

package/dist/client/sqlsaved.js

@@ -0,0 +1,107 @@
+/**
+ * Saved SQL statements: the ones you keep, and the ones your team commits.
+ *
+ * Two stores, one list. A statement in `tablewalk.json` was checked in by
+ * somebody and is the same to the person looking for it as one they saved this
+ * morning — the only difference is whether they may delete it. Merging them
+ * here rather than showing two lists is the whole point: nobody wants to
+ * remember which half of their query library they are looking at.
+ *
+ * Stored as text, never as anything compiled. It stays readable in the editor,
+ * it survives the schema changing underneath it — at worst as a visible error
+ * you can fix rather than a silently wrong answer — and a statement in the
+ * config file can be reviewed by someone who knows SQL and nothing about this
+ * tool.
+ */
+import { api, loadJson, saveJson, state, toast } from './core.js';
+
+const KEY = 'tablewalk.sql.v1';
+
+const connectionKey = () => state.activeConnection ?? 'default';
+
+/** Config-defined statements for the open connection, fetched once per switch. */
+let fromConfig = [];
+let fetchedFor = null;
+
+export async function loadSavedSql() {
+  const connection = connectionKey();
+  try {
+    const data = await api('/api/queries');
+    /* Checked against the connection in hand, not the one this call started
+       on. Two fast switches meant the slower reply landed last and wrote
+       *its* statements under the *current* connection's name — one database's
+       saved SQL listed as another's, offered on a schema it was never written
+       against.
+    
+       The server says which connection answered, so the reply is checked
+       against that rather than against a variable this function captured. */
+    if (data.connection && data.connection !== connectionKey()) return;
+    if (connection !== connectionKey()) return;
+    fromConfig = data.queries ?? [];
+    fetchedFor = connectionKey();
+  } catch {
+    /* A config file that does not answer costs the committed half of the list.
+       The browser's own statements still work, which is the right way round. */
+    if (connection !== connectionKey()) return;
+    fromConfig = [];
+    fetchedFor = connectionKey();
+  }
+}
+
+function localFor(connection) {
+  return loadJson(KEY, {})[connection] ?? [];
+}
+
+/**
+ * Everything saved for this connection, config first.
+ *
+ * Config first because a checked-in statement is usually the canonical one and
+ * the personal ones are variations on it.
+ */
+export function savedStatements() {
+  const connection = connectionKey();
+  const config = fetchedFor === connection ? fromConfig : [];
+  return [
+    ...config.map((q) => ({ ...q, source: 'config' })),
+    ...localFor(connection).map((q) => ({ ...q, source: 'saved' })),
+  ];
+}
+
+/**
+ * Keep a statement under a name.
+ *
+ * A repeated name replaces rather than duplicating: two entries called "Daily
+ * totals" that do different things is worse than losing the older one, and the
+ * person typing the name a second time is almost always correcting the first.
+ * A name the config file already uses is refused instead — that one is not
+ * ours to replace, and silently shadowing it would make a committed statement
+ * mean something different on one machine.
+ */
+export function saveStatement(name, sql) {
+  const connection = connectionKey();
+  const trimmed = name.trim();
+  if (!trimmed) return false;
+
+  if (fromConfig.some((q) => q.name === trimmed)) {
+    toast(`"${trimmed}" is defined in tablewalk.json. Choose another name.`, 'error');
+    return false;
+  }
+
+  const all = loadJson(KEY, {});
+  const kept = (all[connection] ?? []).filter((q) => q.name !== trimmed);
+  kept.push({ name: trimmed, sql: sql.trim() });
+  all[connection] = kept;
+
+  if (!saveJson(KEY, all)) {
+    toast('Could not save — this browser is not allowing local storage.', 'error');
+    return false;
+  }
+  return true;
+}
+
+export function removeStatement(name) {
+  const connection = connectionKey();
+  const all = loadJson(KEY, {});
+  all[connection] = (all[connection] ?? []).filter((q) => q.name !== name);
+  saveJson(KEY, all);
+}