@rebasepro/studio 0.0.1-canary.09e5ec5

package/src/utils/sql_utils.test.ts

@@ -0,0 +1,265 @@
+
+import { describe, it, expect } from "@jest/globals";
+import { determineTableAndPK, extractTablesFromQuery, resolveQueryCollections } from "./sql_utils";
+import { TableInfo } from "../components/SQLEditor/SQLEditor";
+import { EntityCollection } from "@rebasepro/types";
+
+const mockSchemas: Record<string, TableInfo[]> = {
+    "public": [
+        {
+            schemaName: "public",
+            tableName: "users",
+            columns: [
+                { name: "id",
+dataType: "integer",
+isPrimaryKey: true },
+                { name: "email",
+dataType: "text",
+isPrimaryKey: false },
+                { name: "created_at",
+dataType: "timestamp",
+isPrimaryKey: false }
+            ]
+        },
+        {
+            schemaName: "public",
+            tableName: "roles",
+            columns: [
+                { name: "id",
+dataType: "integer",
+isPrimaryKey: true },
+                { name: "role_name",
+dataType: "text",
+isPrimaryKey: false },
+                { name: "created_at",
+dataType: "timestamp",
+isPrimaryKey: false }
+            ]
+        },
+        {
+            schemaName: "public",
+            tableName: "settings", // No primary key
+            columns: [
+                { name: "key",
+dataType: "text",
+isPrimaryKey: false },
+                { name: "value",
+dataType: "text",
+isPrimaryKey: false }
+            ]
+        },
+        {
+            schemaName: "public",
+            tableName: "blog_posts",
+            columns: [
+                { name: "id",
+dataType: "integer",
+isPrimaryKey: true },
+                { name: "title",
+dataType: "text",
+isPrimaryKey: false },
+                { name: "author_id",
+dataType: "integer",
+isPrimaryKey: false }
+            ]
+        },
+        {
+            schemaName: "public",
+            tableName: "order_items", // Composite PK
+            columns: [
+                { name: "order_id",
+dataType: "integer",
+isPrimaryKey: true },
+                { name: "item_id",
+dataType: "integer",
+isPrimaryKey: true },
+                { name: "quantity",
+dataType: "integer",
+isPrimaryKey: false }
+            ]
+        }
+    ]
+};
+
+const mockCollections: EntityCollection[] = [
+    {
+        slug: "users",
+        name: "Users",
+        table: "users",
+        properties: {}
+    } as EntityCollection,
+    {
+        slug: "roles",
+        name: "Roles",
+        table: "roles",
+        properties: {}
+    } as EntityCollection,
+    {
+        slug: "blogPosts",
+        name: "Blog Posts",
+        table: "blog_posts",
+        properties: {}
+    } as EntityCollection,
+    {
+        slug: "blog-entries", // slug with hyphen, no table → falls back to snake_case "blog_entries"
+        name: "Blog Entries",
+        table: "",
+        properties: {}
+    } as EntityCollection
+];
+
+describe("determineTableAndPK", () => {
+    it("resolves basic SELECT with actual PK from schema", () => {
+        const sql = "SELECT * FROM users";
+        const result = determineTableAndPK(sql, "email", mockSchemas);
+        expect(result.tableName).toBe("users");
+        expect(result.primaryKeys).toEqual([{ dbColumn: "id",
+resultColumn: "id" }]);
+    });
+
+    it("resolves aliased FROM", () => {
+        const sql = "SELECT u.email FROM users u";
+        const result = determineTableAndPK(sql, "email", mockSchemas);
+        expect(result.tableName).toBe("users");
+        expect(result.primaryKeys).toEqual([{ dbColumn: "id",
+resultColumn: "id" }]);
+    });
+
+    it("resolves simple unambiguous JOIN", () => {
+        const sql = "SELECT * FROM users u JOIN roles r ON u.role_id = r.id";
+        const result = determineTableAndPK(sql, "email", mockSchemas);
+        expect(result.tableName).toBe("users");
+        expect(result.primaryKeys).toEqual([{ dbColumn: "id",
+resultColumn: "id" }]);
+
+        const result2 = determineTableAndPK(sql, "role_name", mockSchemas);
+        expect(result2.tableName).toBe("roles");
+        expect(result2.primaryKeys).toEqual([{ dbColumn: "id",
+resultColumn: "id" }]);
+    });
+
+    it("resolves aliased PK columns in JOINs", () => {
+        const sql = "SELECT u.id AS user_id, u.email, r.id AS role_id, r.role_name FROM users u JOIN roles r ON u.role_id = r.id";
+        const result = determineTableAndPK(sql, "email", mockSchemas);
+        expect(result.tableName).toBe("users");
+        expect(result.primaryKeys).toEqual([{ dbColumn: "id",
+resultColumn: "user_id" }]);
+
+        const result2 = determineTableAndPK(sql, "role_name", mockSchemas);
+        expect(result2.tableName).toBe("roles");
+        expect(result2.primaryKeys).toEqual([{ dbColumn: "id",
+resultColumn: "role_id" }]);
+    });
+
+    it("resolves aliased edit columns back to DB names", () => {
+        const sql = "SELECT u.email AS user_email FROM users u";
+        const result = determineTableAndPK(sql, "user_email", mockSchemas);
+        expect(result.tableName).toBe("users");
+    });
+
+    it("returns error for ambiguous JOIN columns", () => {
+        const sql = "SELECT * FROM users u JOIN roles r ON u.role_id = r.id";
+        // Both tables have created_at
+        const result = determineTableAndPK(sql, "created_at", mockSchemas);
+        expect(result.error).toContain("Ambiguous column");
+    });
+
+    it("returns error for unsupported non-SELECT queries", () => {
+        const sql = "DELETE FROM users WHERE id = 1";
+        const result = determineTableAndPK(sql, "email", mockSchemas);
+        expect(result.error).toContain("only supported for SELECT");
+    });
+
+    it("returns error for tables without primary keys", () => {
+        const sql = "SELECT * FROM settings";
+        const result = determineTableAndPK(sql, "key", mockSchemas);
+        expect(result.error).toContain("has no primary key defined");
+    });
+
+    it("supports composite primary keys", () => {
+        const sql = "SELECT * FROM order_items";
+        const result = determineTableAndPK(sql, "quantity", mockSchemas);
+        expect(result.tableName).toBe("order_items");
+        expect(result.primaryKeys).toHaveLength(2);
+        expect(result.primaryKeys).toEqual([
+            { dbColumn: "order_id",
+resultColumn: "order_id" },
+            { dbColumn: "item_id",
+resultColumn: "item_id" }
+        ]);
+    });
+});
+
+describe("extractTablesFromQuery", () => {
+    it("extracts a single table", () => {
+        const tables = extractTablesFromQuery("SELECT * FROM users");
+        expect(tables).toEqual([{ name: "users",
+alias: undefined }]);
+    });
+
+    it("extracts aliased tables", () => {
+        const tables = extractTablesFromQuery("SELECT u.email FROM users u");
+        expect(tables).toEqual([{ name: "users",
+alias: "u" }]);
+    });
+
+    it("extracts multiple tables from JOINs", () => {
+        const tables = extractTablesFromQuery("SELECT * FROM users u JOIN roles r ON u.role_id = r.id");
+        expect(tables).toHaveLength(2);
+        expect(tables[0].name).toBe("users");
+        expect(tables[1].name).toBe("roles");
+    });
+
+    it("returns empty for non-SELECT queries", () => {
+        expect(extractTablesFromQuery("DELETE FROM users")).toEqual([]);
+        expect(extractTablesFromQuery("INSERT INTO users (id) VALUES (1)")).toEqual([]);
+    });
+
+    it("returns empty for invalid SQL", () => {
+        expect(extractTablesFromQuery("NOT VALID SQL AT ALL ???")).toEqual([]);
+    });
+});
+
+describe("resolveQueryCollections", () => {
+    it("matches a single CMS collection", () => {
+        const result = resolveQueryCollections("SELECT * FROM users", mockSchemas, mockCollections);
+        expect(result).toHaveLength(1);
+        expect(result[0].tableName).toBe("users");
+        expect(result[0].collection.name).toBe("Users");
+        expect(result[0].columns).toContain("id");
+        expect(result[0].columns).toContain("email");
+    });
+
+    it("matches multiple CMS collections in a JOIN", () => {
+        const result = resolveQueryCollections(
+            "SELECT * FROM users u JOIN roles r ON u.role_id = r.id",
+            mockSchemas,
+            mockCollections
+        );
+        expect(result).toHaveLength(2);
+        expect(result.map(r => r.collection.name).sort()).toEqual(["Roles", "Users"]);
+    });
+
+    it("returns empty when no tables match any collection", () => {
+        const result = resolveQueryCollections("SELECT * FROM settings", mockSchemas, mockCollections);
+        expect(result).toHaveLength(0);
+    });
+
+    it("matches collection by table (not slug)", () => {
+        const result = resolveQueryCollections("SELECT * FROM blog_posts", mockSchemas, mockCollections);
+        expect(result).toHaveLength(1);
+        expect(result[0].collection.slug).toBe("blogPosts");
+    });
+
+    it("returns empty for non-SELECT queries", () => {
+        const result = resolveQueryCollections("DELETE FROM users WHERE id = 1", mockSchemas, mockCollections);
+        expect(result).toHaveLength(0);
+    });
+
+    it("preserves table alias information", () => {
+        const result = resolveQueryCollections("SELECT u.* FROM users u", mockSchemas, mockCollections);
+        expect(result).toHaveLength(1);
+        expect(result[0].tableAlias).toBe("u");
+    });
+});
+

package/src/utils/sql_utils.ts

@@ -0,0 +1,291 @@
+import { parseFirst } from "pgsql-ast-parser";
+import { TableInfo } from "../components/SQLEditor/SQLEditor";
+import { EntityCollection } from "@rebasepro/types";
+
+/**
+ * A table extracted from a SQL query's FROM/JOIN clauses.
+ */
+export interface ExtractedTable {
+    name: string;
+    alias?: string;
+}
+
+/**
+ * A collection matched to a table in a SQL query.
+ */
+export interface ResolvedQueryCollection {
+    /** DB table name from the SQL AST (e.g. "blog_posts") */
+    tableName: string;
+    /** SQL alias if present (e.g. "bp") */
+    tableAlias?: string;
+    /** The matched collection */
+    collection: EntityCollection;
+    /** Columns from this table that are present in the result set */
+    columns: string[];
+    /** The result column name that holds the primary key for this table (e.g. "id", "author_id") */
+    pkColumn?: string;
+}
+
+/**
+ * Extract all tables referenced in a SQL query's FROM and JOIN clauses.
+ * Returns an empty array for non-SELECT queries or parse failures.
+ */
+export function extractTablesFromQuery(sqlString: string): ExtractedTable[] {
+    try {
+        const ast = parseFirst(sqlString);
+        if (ast.type !== "select") return [];
+
+        const tables: ExtractedTable[] = [];
+
+        // pgsql-ast-parser From items — tables and joins with left/right branches
+        type FromNode = { type: string; name?: { name: string; alias?: string }; left?: FromNode; right?: FromNode };
+        const processFrom = (fromItems: FromNode[]) => {
+            for (const item of fromItems) {
+                if (item.type === "table" && item.name) {
+                    tables.push({ name: item.name.name,
+alias: item.name.alias });
+                }
+                if (item.type === "join") {
+                    if (item.left) processFrom([item.left]);
+                    if (item.right) processFrom([item.right]);
+                }
+            }
+        };
+
+        if (ast.from) {
+            processFrom(ast.from);
+        }
+
+        return tables;
+    } catch {
+        return [];
+    }
+}
+
+import { toSnakeCase } from "@rebasepro/utils";
+
+/**
+ * Resolve which collections are referenced by a SQL query.
+ *
+ * Parses the SQL, extracts table names, and matches each against
+ * registered collections via `collection.table` (falling back to
+ * snake_case of `collection.slug`).
+ *
+ * For each matched collection, determines which result columns
+ * belong to that table using the database schema information.
+ */
+export function resolveQueryCollections(
+    sqlString: string,
+    schemas: Record<string, TableInfo[]>,
+    collections: EntityCollection[],
+    resultColumns?: string[]
+): ResolvedQueryCollection[] {
+    const tables = extractTablesFromQuery(sqlString);
+    if (tables.length === 0) return [];
+
+    // Parse the AST to resolve SELECT column aliases
+    const selectColumns: { table?: string; column: string; alias?: string }[] = [];
+    try {
+        const ast = parseFirst(sqlString);
+        if (ast.type === "select" && ast.columns) {
+            for (const col of ast.columns) {
+                if (col.expr?.type === "ref") {
+                    selectColumns.push({
+                        table: col.expr.table?.name,
+                        column: col.expr.name,
+                        alias: col.alias?.name
+                    });
+                }
+            }
+        }
+    } catch { /* parse failure is ok, we'll fall back */ }
+
+    const results: ResolvedQueryCollection[] = [];
+
+    for (const table of tables) {
+        // Match table name against collection table or slug->snake_case
+        const matched = collections.find(c => {
+            const tableName = (c as any).table || toSnakeCase(c.slug);
+            return tableName === table.name;
+        });
+
+        if (!matched) continue;
+
+        // Find columns belonging to this table from the schema
+        const tableColumns: string[] = [];
+        for (const schemaEntries of Object.values(schemas)) {
+            const tableInfo = schemaEntries.find(t => t.tableName === table.name);
+            if (tableInfo) {
+                tableColumns.push(...tableInfo.columns.map(c => c.name));
+                break;
+            }
+        }
+
+        // Determine which result column holds the PK ("id") for this table.
+        // 1. Check parsed SELECT columns for an explicit "id" column from this table (by name or alias)
+        // 2. Fall back to checking if result columns contain "id"
+        let pkColumn: string | undefined;
+
+        // Look in the AST select columns for `table.id` or `alias.id`
+        const tableRef = table.alias || table.name;
+        const idSelectCol = selectColumns.find(
+            sc => sc.column === "id" && (!sc.table || sc.table === tableRef || sc.table === table.name)
+        );
+        if (idSelectCol) {
+            pkColumn = idSelectCol.alias || idSelectCol.column; // use alias if present
+        }
+
+        // If we didn't find it from the AST (e.g. SELECT *), check if result columns have "id"
+        if (!pkColumn && resultColumns) {
+            if (resultColumns.includes("id")) {
+                pkColumn = "id";
+            }
+        }
+
+        // If still not found, fall back to checking tableColumns
+        if (!pkColumn && tableColumns.includes("id")) {
+            pkColumn = "id";
+        }
+
+        results.push({
+            tableName: table.name,
+            tableAlias: table.alias,
+            collection: matched,
+            columns: tableColumns,
+            pkColumn
+        });
+    }
+
+    return results;
+}
+
+export interface PKMapping {
+    /** The actual column name in the database table */
+    dbColumn: string;
+    /** The column name as it appears in the query result set (may be aliased) */
+    resultColumn: string;
+}
+
+export interface TableAndPKResult {
+    tableName?: string;
+    primaryKeys?: PKMapping[];
+    error?: string;
+}
+
+export function determineTableAndPK(sqlString: string, columnKey: string, schemas: Record<string, TableInfo[]>): TableAndPKResult {
+    try {
+        const tables = extractTablesFromQuery(sqlString);
+
+        const ast = parseFirst(sqlString);
+        if (ast.type !== "select") {
+            return { error: "Inline editing is only supported for SELECT queries." };
+        }
+
+        if (tables.length === 0) {
+            return { error: "Could not find any tables in the query." };
+        }
+
+        // Parse SELECT columns to resolve aliases
+        const selectColumns: { table?: string; column: string; alias?: string }[] = [];
+        if (ast.columns) {
+            for (const col of ast.columns) {
+                if (col.expr?.type === "ref") {
+                    selectColumns.push({
+                        table: col.expr.table?.name,
+                        column: col.expr.name,
+                        alias: col.alias?.name
+                    });
+                }
+            }
+        }
+
+        // Resolve which DB column `columnKey` refers to (it might be aliased)
+        const resolvedColumn = selectColumns.find(
+            sc => (sc.alias === columnKey) || (!sc.alias && sc.column === columnKey)
+        );
+        const actualDbColumnName = resolvedColumn?.column ?? columnKey;
+        const columnTableRef = resolvedColumn?.table; // e.g. "p" or "posts"
+
+        // Resolve the table for the edited column
+        let resolvedTableName: string | null = null;
+
+        if (tables.length === 1) {
+            resolvedTableName = tables[0].name;
+        } else {
+            // If the AST tells us which table, use that
+            if (columnTableRef) {
+                const matchedTable = tables.find(
+                    t => t.alias === columnTableRef || t.name === columnTableRef
+                );
+                if (matchedTable) {
+                    resolvedTableName = matchedTable.name;
+                }
+            }
+
+            // Otherwise, look up which schema table has this column
+            if (!resolvedTableName) {
+                const matchedTables = tables.filter(t => {
+                    for (const schema of Object.values(schemas)) {
+                        const tableInfo = schema.find(ti => ti.tableName === t.name);
+                        if (tableInfo && tableInfo.columns.some(c => c.name === actualDbColumnName)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+
+                if (matchedTables.length === 1) {
+                    resolvedTableName = matchedTables[0].name;
+                } else if (matchedTables.length > 1) {
+                    return { error: `Ambiguous column "${columnKey}": Found in multiple queried tables.` };
+                } else {
+                    return { error: `Could not find column "${columnKey}" in the queried tables.` };
+                }
+            }
+        }
+
+        if (!resolvedTableName) {
+            return { error: "Could not resolve the target table." };
+        }
+
+        // Find the table's actual primary key columns from the schema
+        let pkDbColumns: string[] = [];
+        for (const schema of Object.values(schemas)) {
+            const tableInfo = schema.find(t => t.tableName === resolvedTableName);
+            if (tableInfo) {
+                pkDbColumns = tableInfo.columns
+                    .filter(c => c.isPrimaryKey)
+                    .map(c => c.name);
+                break;
+            }
+        }
+
+        if (pkDbColumns.length === 0) {
+            return { error: `Table "${resolvedTableName}" has no primary key defined.` };
+        }
+
+        // Find the table's alias in the query (for resolving PK result column names)
+        const tableEntry = tables.find(t => t.name === resolvedTableName);
+        const tableAlias = tableEntry?.alias;
+
+        // Map each PK db column to its result column name (resolving aliases)
+        const primaryKeys: PKMapping[] = pkDbColumns.map(dbCol => {
+            // Find the SELECT column for this PK
+            const selectCol = selectColumns.find(
+                sc => sc.column === dbCol &&
+                    (!sc.table || sc.table === (tableAlias || resolvedTableName))
+            );
+            return {
+                dbColumn: dbCol,
+                resultColumn: selectCol?.alias || selectCol?.column || dbCol
+            };
+        });
+
+        return { tableName: resolvedTableName,
+primaryKeys };
+    } catch (e: unknown) {
+        console.warn("Failed to parse SQL AST:", e);
+        const message = e instanceof Error ? e.message : String(e);
+        return { error: `Could not safely parse query for inline editing: ${message}` };
+    }
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />