codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/sql/refs.js

@@ -0,0 +1,357 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var refs_exports = {};
+__export(refs_exports, {
+  extractTableRefs: () => extractTableRefs,
+  looksLikeSql: () => looksLikeSql
+});
+module.exports = __toCommonJS(refs_exports);
+var import_tokenizer = require("./tokenizer");
+const AFTER_TABLE = /* @__PURE__ */ new Set([
+  "WHERE",
+  "JOIN",
+  "INNER",
+  "LEFT",
+  "RIGHT",
+  "FULL",
+  "CROSS",
+  "OUTER",
+  "NATURAL",
+  "LATERAL",
+  "ON",
+  "USING",
+  "GROUP",
+  "ORDER",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "FETCH",
+  "WINDOW",
+  "UNION",
+  "INTERSECT",
+  "EXCEPT",
+  "RETURNING",
+  "FOR",
+  "SET",
+  "VALUES",
+  "INTO",
+  "FROM",
+  "FORCE",
+  "USE",
+  "IGNORE",
+  "FINAL",
+  "FILTER",
+  "FIRST",
+  "FOLLOWING",
+  "FORMAT",
+  "OPTION",
+  "FORCESEEK"
+]);
+const CLAUSE_END = /* @__PURE__ */ new Set([
+  "WHERE",
+  "GROUP",
+  "ORDER",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "FETCH",
+  "WINDOW",
+  "UNION",
+  "INTERSECT",
+  "EXCEPT",
+  "SET",
+  "VALUES",
+  "ON",
+  "USING",
+  "SELECT",
+  "RETURNING",
+  "JOIN",
+  "INNER",
+  "LEFT",
+  "RIGHT",
+  "FULL",
+  "CROSS",
+  "OUTER",
+  "NATURAL",
+  "LATERAL",
+  "WITH",
+  "AS",
+  "INTO",
+  "FROM",
+  "AND",
+  "OR",
+  "NOT",
+  "DELETE",
+  "INSERT",
+  "UPDATE",
+  "CREATE",
+  "DROP",
+  "ALTER",
+  "TRUNCATE",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "DO",
+  "NOTHING",
+  "CONFLICT",
+  "DUPLICATE",
+  "KEY",
+  "FOR",
+  "BY",
+  "DESC",
+  "ASC",
+  "ONLY",
+  "TABLE",
+  "PARTITION"
+]);
+const JOIN_WORDS = ["JOIN"];
+function collectCteNames(tokens) {
+  const names = /* @__PURE__ */ new Set();
+  for (let i = 0; i < tokens.length; i++) {
+    if (!(0, import_tokenizer.isWord)(tokens[i], "WITH")) continue;
+    let j = i + 1;
+    if ((0, import_tokenizer.isWord)(tokens[j], "RECURSIVE")) j++;
+    for (; ; ) {
+      const nameTok = tokens[j];
+      if (!(0, import_tokenizer.isNameToken)(nameTok)) break;
+      let k = j + 1;
+      if (tokens[k]?.value === "(") k = skipParens(tokens, k);
+      if ((0, import_tokenizer.isWord)(tokens[k], "AS")) k++;
+      if ((0, import_tokenizer.isWord)(tokens[k], "MATERIALIZED") || (0, import_tokenizer.isWord)(tokens[k], "NOT")) {
+        while (tokens[k] && tokens[k].value !== "(") k++;
+      }
+      if (tokens[k]?.value !== "(") break;
+      names.add(nameTok.value.toLowerCase());
+      k = skipParens(tokens, k);
+      if (tokens[k]?.value === ",") {
+        j = k + 1;
+        continue;
+      }
+      break;
+    }
+  }
+  return names;
+}
+function skipParens(tokens, open) {
+  let depth = 0;
+  let i = open;
+  for (; i < tokens.length; i++) {
+    if (tokens[i].value === "(") depth++;
+    else if (tokens[i].value === ")") {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+  }
+  return i;
+}
+function readQualifiedName(tokens, i) {
+  if (!(0, import_tokenizer.isNameToken)(tokens[i])) return null;
+  const parts = [tokens[i].value];
+  let j = i + 1;
+  while (tokens[j]?.value === "." && (0, import_tokenizer.isNameToken)(tokens[j + 1])) {
+    parts.push(tokens[j + 1].value);
+    j += 2;
+  }
+  const table = parts[parts.length - 1];
+  const schema = parts.length > 1 ? parts[parts.length - 2] : null;
+  return {
+    raw: parts.join("."),
+    table,
+    schema,
+    next: j,
+    followedByParen: tokens[j]?.value === "("
+  };
+}
+function skipAlias(tokens, i) {
+  let j = i;
+  if ((0, import_tokenizer.isWord)(tokens[j], "AS")) {
+    j++;
+    if ((0, import_tokenizer.isNameToken)(tokens[j])) j++;
+    return j;
+  }
+  const tok = tokens[j];
+  if ((0, import_tokenizer.isNameToken)(tok) && !CLAUSE_END.has(tok.value.toUpperCase())) j++;
+  return j;
+}
+function consumeTableList(tokens, i, op, keyword, ctes, out, allowParen = false) {
+  let j = i;
+  for (; ; ) {
+    if (tokens[j]?.value === "(") return j;
+    const name = readQualifiedName(tokens, j);
+    if (!name) return j;
+    if (name.followedByParen && !allowParen) {
+      j = skipAlias(tokens, skipParens(tokens, name.next));
+      if (tokens[j]?.value === ",") {
+        j++;
+        continue;
+      }
+      return j;
+    }
+    if (!ctes.has(name.table.toLowerCase())) {
+      out.push({
+        table: name.table.toLowerCase(),
+        raw: name.raw,
+        schema: name.schema,
+        op,
+        keyword,
+        line: tokens[j].line
+      });
+    }
+    j = name.followedByParen && allowParen ? skipParens(tokens, name.next) : skipAlias(tokens, name.next);
+    if (tokens[j]?.value === ",") {
+      j++;
+      continue;
+    }
+    return j;
+  }
+}
+function extractTableRefs(sql) {
+  if (!sql || sql.length === 0) return [];
+  const tokens = (0, import_tokenizer.tokenize)(sql);
+  if (tokens.length === 0) return [];
+  const ctes = collectCteNames(tokens);
+  const out = [];
+  let pendingDelete = false;
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.value === ";") {
+      pendingDelete = false;
+      continue;
+    }
+    if (t.type !== "word") continue;
+    const w = t.value.toUpperCase();
+    if (w === "ON") {
+      pendingDelete = false;
+      continue;
+    }
+    if (w === "DELETE") {
+      pendingDelete = true;
+      continue;
+    }
+    if (w === "FROM") {
+      const op = pendingDelete ? "write" : "read";
+      const keyword = pendingDelete ? "DELETE FROM" : "FROM";
+      pendingDelete = false;
+      i = consumeTableList(tokens, i + 1, op, keyword, ctes, out) - 1;
+      continue;
+    }
+    if (JOIN_WORDS.includes(w)) {
+      i = consumeTableList(tokens, i + 1, "read", "JOIN", ctes, out) - 1;
+      continue;
+    }
+    if (w === "INTO") {
+      i = consumeTableList(tokens, i + 1, "write", "INSERT INTO", ctes, out, true) - 1;
+      continue;
+    }
+    if (w === "UPDATE") {
+      i = consumeTableList(tokens, i + 1, "write", "UPDATE", ctes, out, true) - 1;
+      continue;
+    }
+    if (w === "TRUNCATE") {
+      let j = i + 1;
+      if ((0, import_tokenizer.isWord)(tokens[j], "TABLE")) j++;
+      i = consumeTableList(tokens, j, "write", "TRUNCATE", ctes, out) - 1;
+      continue;
+    }
+    if (w === "SELECT" || w === "INSERT" || w === "CREATE") pendingDelete = false;
+  }
+  return dedupe(out);
+}
+function dedupe(refs) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const key = `${ref.schema ?? ""}.${ref.table}:${ref.op}`;
+    if (!seen.has(key)) seen.set(key, ref);
+  }
+  return [...seen.values()];
+}
+function looksLikeSql(text) {
+  if (!text || text.length < 12) return false;
+  const tokens = (0, import_tokenizer.tokenize)(text);
+  if (tokens.length < 3) return false;
+  const w = (i) => tokens[i]?.type === "word" ? tokens[i].value.toUpperCase() : "";
+  const afterName = (i) => {
+    const name = readQualifiedName(tokens, i);
+    return name ? name.next : -1;
+  };
+  const isBoundary = (i) => {
+    if (i >= tokens.length) return true;
+    const t = tokens[i];
+    if (t.value === ";" || t.value === "(") return true;
+    return t.type === "word" && CLAUSE_END.has(t.value.toUpperCase());
+  };
+  switch (w(0)) {
+    case "SELECT": {
+      const from = tokens.findIndex(
+        (t, i) => i > 0 && t.type === "word" && t.value.toUpperCase() === "FROM"
+      );
+      if (from === -1) return false;
+      const after = afterName(from + 1);
+      if (after === -1) return false;
+      const structural = (i) => i >= tokens.length || tokens[i].value === ";" || tokens[i].value === "," || tokens[i].value === "(" || tokens[i].value === ")";
+      const wordAt = (i) => tokens[i]?.type === "word" ? tokens[i].value.toUpperCase() : "";
+      const acceptable = (i) => {
+        if (structural(i)) return true;
+        const kw = wordAt(i);
+        if (kw === "WITH") return tokens[i + 1]?.value === "(";
+        return AFTER_TABLE.has(kw);
+      };
+      if (acceptable(after)) return true;
+      let k = after;
+      if (wordAt(k) === "AS") k += 1;
+      if (tokens[k]?.type === "word" && !CLAUSE_END.has(wordAt(k))) k += 1;
+      else return false;
+      return acceptable(k);
+    }
+    case "INSERT":
+    case "REPLACE": {
+      if (w(1) !== "INTO") return false;
+      const after = afterName(2);
+      if (after === -1) return false;
+      return tokens[after]?.value === "(" || ["VALUES", "SELECT", "SET", "DEFAULT", "WITH"].includes(w(after));
+    }
+    case "MERGE":
+      return w(1) === "INTO" && afterName(2) !== -1;
+    case "UPDATE": {
+      const after = afterName(1);
+      if (after === -1) return false;
+      return w(after) === "SET" || w(after + 1) === "SET";
+    }
+    case "DELETE": {
+      if (w(1) !== "FROM") return false;
+      const after = afterName(2);
+      if (after === -1) return false;
+      return isBoundary(after);
+    }
+    case "TRUNCATE": {
+      const start = w(1) === "TABLE" ? 2 : 1;
+      const after = afterName(start);
+      return after !== -1 && isBoundary(after);
+    }
+    case "WITH": {
+      return collectCteNames(tokens).size > 0;
+    }
+    default:
+      return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractTableRefs,
+  looksLikeSql
+});

package/src/backend/services/sql/schema.js

@@ -0,0 +1,312 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  applyMigrationFold: () => applyMigrationFold,
+  extractSchemaStatements: () => extractSchemaStatements,
+  extractSqlSymbols: () => extractSqlSymbols,
+  foldMigrations: () => foldMigrations,
+  looksLikeMigrationsDir: () => looksLikeMigrationsDir,
+  sortMigrations: () => sortMigrations
+});
+module.exports = __toCommonJS(schema_exports);
+var import_tokenizer = require("./tokenizer");
+const CREATE_MODIFIERS = /* @__PURE__ */ new Set([
+  "OR",
+  "REPLACE",
+  "TEMP",
+  "TEMPORARY",
+  "UNLOGGED",
+  "GLOBAL",
+  "LOCAL",
+  "MATERIALIZED",
+  "RECURSIVE",
+  "EXTERNAL",
+  "VIRTUAL"
+]);
+function readName(tokens, i) {
+  if (!(0, import_tokenizer.isNameToken)(tokens[i])) return null;
+  const parts = [tokens[i].value];
+  let j = i + 1;
+  while (tokens[j]?.value === "." && (0, import_tokenizer.isNameToken)(tokens[j + 1])) {
+    parts.push(tokens[j + 1].value);
+    j += 2;
+  }
+  const bare = parts[parts.length - 1];
+  return {
+    raw: parts.join("."),
+    name: bare.toLowerCase(),
+    schema: parts.length > 1 ? parts[parts.length - 2] : null,
+    next: j
+  };
+}
+function skipIfExists(tokens, i) {
+  let j = i;
+  if (!(0, import_tokenizer.isWord)(tokens[j], "IF")) return j;
+  j++;
+  if ((0, import_tokenizer.isWord)(tokens[j], "NOT")) j++;
+  if ((0, import_tokenizer.isWord)(tokens[j], "EXISTS")) j++;
+  return j;
+}
+function statementEndLine(tokens, from) {
+  let depth = 0;
+  for (let i = from; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.value === "(") depth++;
+    else if (t.value === ")") depth--;
+    else if (t.value === ";" && depth <= 0) return t.line;
+  }
+  return tokens[tokens.length - 1]?.line ?? tokens[from]?.line ?? 1;
+}
+function extractSchemaStatements(sql) {
+  const tokens = (0, import_tokenizer.tokenize)(sql);
+  const out = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.type !== "word") continue;
+    const verb = t.value.toUpperCase();
+    if (verb === "CREATE") {
+      const modifiers = [];
+      let j = i + 1;
+      while (tokens[j]?.type === "word" && CREATE_MODIFIERS.has(tokens[j].value.toUpperCase())) {
+        const m = tokens[j].value.toLowerCase();
+        if (m !== "or" && m !== "replace") modifiers.push(m);
+        j++;
+      }
+      const objectWord = tokens[j]?.type === "word" ? tokens[j].value.toUpperCase() : "";
+      let kind = null;
+      if (objectWord === "TABLE") kind = "table";
+      else if (objectWord === "VIEW") kind = "view";
+      else if (objectWord === "FUNCTION" || objectWord === "PROCEDURE") kind = "proc";
+      if (!kind) continue;
+      j = skipIfExists(tokens, j + 1);
+      const name = readName(tokens, j);
+      if (!name) continue;
+      out.push({
+        action: "create",
+        kind,
+        name: name.name,
+        raw: name.raw,
+        schema: name.schema,
+        modifiers,
+        line: t.line,
+        startLine: t.line,
+        endLine: statementEndLine(tokens, name.next)
+      });
+      i = name.next - 1;
+      continue;
+    }
+    if (verb === "ALTER" && (0, import_tokenizer.isWord)(tokens[i + 1], "TABLE")) {
+      let j = skipIfExists(tokens, i + 2);
+      if ((0, import_tokenizer.isWord)(tokens[j], "ONLY")) j++;
+      const name = readName(tokens, j);
+      if (!name) continue;
+      const k = name.next;
+      if ((0, import_tokenizer.isWord)(tokens[k], "RENAME") && (0, import_tokenizer.isWord)(tokens[k + 1], "TO")) {
+        const target = readName(tokens, k + 2);
+        if (target) {
+          out.push({
+            action: "rename",
+            kind: "table",
+            name: name.name,
+            raw: name.raw,
+            schema: name.schema,
+            renameTo: target.name,
+            modifiers: [],
+            line: t.line,
+            startLine: t.line,
+            endLine: t.line
+          });
+          i = target.next - 1;
+          continue;
+        }
+      }
+      out.push({
+        action: "alter",
+        kind: "table",
+        name: name.name,
+        raw: name.raw,
+        schema: name.schema,
+        modifiers: [],
+        line: t.line,
+        startLine: t.line,
+        endLine: t.line
+      });
+      i = k - 1;
+      continue;
+    }
+    if (verb === "DROP") {
+      const objectWord = tokens[i + 1]?.type === "word" ? tokens[i + 1].value.toUpperCase() : "";
+      let kind = null;
+      if (objectWord === "TABLE") kind = "table";
+      else if (objectWord === "VIEW") kind = "view";
+      else if (objectWord === "MATERIALIZED" && (0, import_tokenizer.isWord)(tokens[i + 2], "VIEW")) kind = "view";
+      else if (objectWord === "FUNCTION" || objectWord === "PROCEDURE") kind = "proc";
+      if (!kind) continue;
+      let j = i + (objectWord === "MATERIALIZED" ? 3 : 2);
+      j = skipIfExists(tokens, j);
+      for (; ; ) {
+        const name = readName(tokens, j);
+        if (!name) break;
+        out.push({
+          action: "drop",
+          kind,
+          name: name.name,
+          raw: name.raw,
+          schema: name.schema,
+          modifiers: [],
+          line: t.line,
+          startLine: t.line,
+          endLine: t.line
+        });
+        j = name.next;
+        if (tokens[j]?.value === ",") {
+          j++;
+          continue;
+        }
+        break;
+      }
+      i = j - 1;
+      continue;
+    }
+  }
+  return out;
+}
+function extractSqlSymbols(sql) {
+  const symbols = [];
+  for (const stmt of extractSchemaStatements(sql)) {
+    if (stmt.action !== "create") continue;
+    const kind = stmt.kind === "proc" ? "function" : "class";
+    const modifiers = [stmt.kind, ...stmt.modifiers];
+    if (stmt.schema) modifiers.push(`schema:${stmt.schema}`);
+    symbols.push({
+      name: stmt.raw,
+      kind,
+      startLine: stmt.startLine,
+      endLine: stmt.endLine,
+      children: [],
+      modifiers
+    });
+  }
+  return symbols;
+}
+function foldKey(schema, name) {
+  return schema ? `${schema.toLowerCase()}.${name.toLowerCase()}` : name.toLowerCase();
+}
+function foldKeyOfWritten(written) {
+  const parts = written.split(".");
+  const bare = parts.pop() ?? "";
+  return foldKey(parts.length ? parts.join(".") : null, bare);
+}
+function foldMigrations(files) {
+  const live = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const stmt of extractSchemaStatements(file.sql)) {
+      switch (stmt.action) {
+        case "create": {
+          if (stmt.kind === "proc") break;
+          if (!live.has(foldKey(stmt.schema, stmt.name))) {
+            live.set(foldKey(stmt.schema, stmt.name), {
+              name: stmt.name,
+              raw: stmt.raw,
+              kind: stmt.kind,
+              definedIn: file.path,
+              startLine: stmt.startLine,
+              endLine: stmt.endLine,
+              alteredIn: []
+            });
+          }
+          break;
+        }
+        case "alter": {
+          const existing = live.get(foldKey(stmt.schema, stmt.name));
+          if (existing && !existing.alteredIn.includes(file.path)) {
+            existing.alteredIn.push(file.path);
+          }
+          break;
+        }
+        case "rename": {
+          const existing = live.get(foldKey(stmt.schema, stmt.name));
+          if (existing && stmt.renameTo) {
+            live.delete(foldKey(stmt.schema, stmt.name));
+            live.set(foldKey(stmt.schema, stmt.renameTo), { ...existing, name: stmt.renameTo, raw: stmt.renameTo });
+          }
+          break;
+        }
+        case "drop":
+          live.delete(foldKey(stmt.schema, stmt.name));
+          break;
+      }
+    }
+  }
+  return live;
+}
+function looksLikeMigrationsDir(fileNames) {
+  const sqlFiles = fileNames.filter((f) => f.toLowerCase().endsWith(".sql"));
+  if (sqlFiles.length < 2) return false;
+  const numbered = sqlFiles.filter((f) => /^(\d{3,}|\d{8,})[._-]/.test(f.replace(/^.*[\\/]/, "")));
+  return numbered.length >= Math.ceil(sqlFiles.length / 2);
+}
+function sortMigrations(files) {
+  const keyOf = (p) => {
+    const base = p.replace(/^.*[\\/]/, "");
+    const m = /^(\d+)/.exec(base);
+    return [m ? Number(m[1]) : Number.MAX_SAFE_INTEGER, base];
+  };
+  return [...files].sort((a, b) => {
+    const [an, as_] = keyOf(a.path);
+    const [bn, bs] = keyOf(b.path);
+    return an !== bn ? an - bn : as_.localeCompare(bs);
+  });
+}
+function applyMigrationFold(sqlFiles, readFile) {
+  const byDir = /* @__PURE__ */ new Map();
+  for (const file of sqlFiles) {
+    const dir = file.path.replace(/[\\/][^\\/]*$/, "");
+    const bucket = byDir.get(dir);
+    if (bucket) bucket.push(file);
+    else byDir.set(dir, [file]);
+  }
+  for (const [, files] of byDir) {
+    if (!looksLikeMigrationsDir(files.map((f) => f.path))) continue;
+    const ordered = sortMigrations(files);
+    const withSql = [];
+    for (const file of ordered) {
+      const sql = readFile(file.path);
+      if (sql !== null) withSql.push({ path: file.path, sql });
+    }
+    if (withSql.length === 0) continue;
+    const live = foldMigrations(withSql);
+    for (const file of ordered) {
+      file.symbols = file.symbols.filter((sym) => {
+        const survivor = live.get(foldKeyOfWritten(sym.name));
+        if (!survivor) return sym.modifiers.includes("proc");
+        return survivor.definedIn === file.path;
+      });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyMigrationFold,
+  extractSchemaStatements,
+  extractSqlSymbols,
+  foldMigrations,
+  looksLikeMigrationsDir,
+  sortMigrations
+});