@rebasepro/studio 0.17.3 → 0.18.1

package/src/utils/parseSpec.test.ts

@@ -1,309 +0,0 @@
-import { parseOpenApiSpec, resolveRefName, resolveRef } from "../components/ApiExplorer/parseSpec";
-import type { OpenApiParameter, OpenApiSpec } from "../components/ApiExplorer/types";
-
-function makeSpec(overrides: Partial<OpenApiSpec> = {}): OpenApiSpec {
-    return {
-        // `openapi` and `info` are required on `OpenApiSpec` and this builder
-        // supplied neither, so every fixture below was one cast away from being
-        // a document no parser would accept.
-        openapi: "3.0.0",
-        info: { title: "Test API",
-version: "1.0.0" },
-        paths: {},
-        tags: [],
-        ...overrides
-    };
-}
-
-describe("parseOpenApiSpec", () => {
-    it("returns empty groups and endpoints for spec with no paths", () => {
-        const result = parseOpenApiSpec(makeSpec());
-        expect(result.groups).toEqual([]);
-        expect(result.allEndpoints).toEqual([]);
-    });
-
-    it("parses a single GET endpoint", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    get: {
-                        summary: "List users",
-                        tags: ["Users"]
-                    }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.allEndpoints).toHaveLength(1);
-        expect(result.allEndpoints[0].method).toBe("get");
-        expect(result.allEndpoints[0].path).toBe("/api/data/users");
-        expect(result.allEndpoints[0].summary).toBe("List users");
-    });
-
-    it("groups endpoints by tag", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"],
-summary: "List users" }
-                },
-                "/api/data/posts": {
-                    get: { tags: ["Posts"],
-summary: "List posts" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.groups).toHaveLength(2);
-        expect(result.groups.map(g => g.tag).sort()).toEqual(["Posts", "Users"]);
-    });
-
-    it("assigns endpoints with no tags to 'Other' group", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/misc": {
-                    get: { summary: "Misc endpoint" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.groups).toHaveLength(1);
-        expect(result.groups[0].tag).toBe("Other");
-    });
-
-    it("strips /api/data prefix from shortPath", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"],
-summary: "List" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.allEndpoints[0].shortPath).toBe("/users");
-    });
-
-    it("uses / as shortPath when path is exactly /api/data", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data": {
-                    get: { tags: ["Root"],
-summary: "Root" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.allEndpoints[0].shortPath).toBe("/");
-    });
-
-    it("sorts endpoints within a group by path then method", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    delete: { tags: ["Users"],
-summary: "Delete" },
-                    get: { tags: ["Users"],
-summary: "List" },
-                    post: { tags: ["Users"],
-summary: "Create" }
-                },
-                "/api/data/users/{id}": {
-                    get: { tags: ["Users"],
-summary: "Get one" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        const users = result.groups.find(g => g.tag === "Users");
-        expect(users).toBeDefined();
-        // Path first, then the CRUD method order — not the order the spec
-        // happened to declare them in (delete, get, post above). Asserting only
-        // `[0]` left both halves of that free to be wrong.
-        expect(users!.endpoints.map(e => `${e.path}:${e.method}`)).toEqual([
-            "/api/data/users:get",
-            "/api/data/users:post",
-            "/api/data/users:delete",
-            "/api/data/users/{id}:get"
-        ]);
-    });
-
-    it("respects tag order from spec.tags", () => {
-        const spec = makeSpec({
-            tags: [
-                { name: "Posts",
-description: "Blog posts" },
-                { name: "Users",
-description: "User management" }
-            ],
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"],
-summary: "List users" }
-                },
-                "/api/data/posts": {
-                    get: { tags: ["Posts"],
-summary: "List posts" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.groups[0].tag).toBe("Posts");
-        expect(result.groups[1].tag).toBe("Users");
-    });
-
-    it("includes tag descriptions from spec.tags", () => {
-        const spec = makeSpec({
-            tags: [
-                { name: "Users",
-description: "User management endpoints" }
-            ],
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"],
-summary: "List" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.groups[0].description).toBe("User management endpoints");
-    });
-
-    it("extracts parameters and requestBody", () => {
-        // Annotated: inferred, `in` widens to `string` and the array is not an
-        // `OpenApiParameter[]` — the very shape this test says it extracts.
-        const params: OpenApiParameter[] = [{ name: "id",
-in: "path",
-required: true }];
-        const requestBody = { content: { "application/json": { schema: {} } } };
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users/{id}": {
-                    put: {
-                        tags: ["Users"],
-                        parameters: params,
-                        requestBody
-                    }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.allEndpoints[0].parameters).toEqual(params);
-        expect(result.allEndpoints[0].requestBody).toEqual(requestBody);
-    });
-
-    it("handles multiple HTTP methods on same path", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"],
-summary: "List" },
-                    post: { tags: ["Users"],
-summary: "Create" }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.allEndpoints).toHaveLength(2);
-        const methods = result.allEndpoints.map(e => e.method).sort();
-        expect(methods).toEqual(["get", "post"]);
-    });
-
-    it("filters out non-standard HTTP methods", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"],
-summary: "List" },
-                    options: { tags: ["Users"],
-summary: "Options" },
-                    parameters: [{ name: "test" }] as unknown as Record<string, unknown>
-                } as unknown as Record<string, never>
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        // Only 'get' should be included (not options, not parameters)
-        expect(result.allEndpoints).toHaveLength(1);
-        expect(result.allEndpoints[0].method).toBe("get");
-    });
-
-    it("generates unique endpoint IDs", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"] },
-                    post: { tags: ["Users"] }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        const ids = result.allEndpoints.map(e => e.id);
-        expect(ids[0]).toBe("get:/api/data/users");
-        expect(ids[1]).toBe("post:/api/data/users");
-    });
-
-    it("defaults summary and description to empty strings", () => {
-        const spec = makeSpec({
-            paths: {
-                "/api/data/users": {
-                    get: { tags: ["Users"] }
-                }
-            }
-        });
-        const result = parseOpenApiSpec(spec);
-        expect(result.allEndpoints[0].summary).toBe("");
-        expect(result.allEndpoints[0].description).toBe("");
-    });
-});
-
-describe("resolveRefName", () => {
-    it("extracts schema name from standard $ref", () => {
-        expect(resolveRefName("#/components/schemas/Author")).toBe("Author");
-    });
-
-    it("extracts last segment from deep path", () => {
-        expect(resolveRefName("#/components/schemas/nested/Type")).toBe("Type");
-    });
-
-    it("handles single-segment ref", () => {
-        expect(resolveRefName("Author")).toBe("Author");
-    });
-
-    it("handles empty string", () => {
-        expect(resolveRefName("")).toBe("");
-    });
-});
-
-describe("resolveRef", () => {
-    it("resolves a valid schema ref", () => {
-        const spec = makeSpec({
-            components: {
-                schemas: {
-                    Author: { type: "object",
-properties: { name: { type: "string" } } }
-                }
-            }
-        });
-
-        const result = resolveRef(spec, "#/components/schemas/Author");
-        expect(result).toEqual({
-            type: "object",
-            properties: { name: { type: "string" } }
-        });
-    });
-
-    it("returns empty object for invalid ref", () => {
-        const spec = makeSpec();
-        const result = resolveRef(spec, "#/components/schemas/NonExistent");
-        expect(result).toEqual({});
-    });
-
-    it("resolves nested refs", () => {
-        const spec = {
-            info: { title: "Test API" }
-        } as unknown as OpenApiSpec;
-
-        const result = resolveRef(spec, "#/info/title");
-        expect(result).toBe("Test API");
-    });
-});

package/src/utils/sql_utils.test.ts

@@ -1,265 +0,0 @@
-
-import { describe, it, expect } from "@jest/globals";
-import { determineTableAndPK, extractTablesFromQuery, resolveQueryCollections } from "./sql_utils";
-import type { TableInfo } from "../components/SQLEditor/sql_editor_types";
-import type { AdminCollection } from "@rebasepro/cms-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: AdminCollection[] = [
-    {
-        slug: "users",
-        name: "Users",
-        table: "users",
-        properties: {}
-    } as AdminCollection,
-    {
-        slug: "roles",
-        name: "Roles",
-        table: "roles",
-        properties: {}
-    } as AdminCollection,
-    {
-        slug: "blogPosts",
-        name: "Blog Posts",
-        table: "blog_posts",
-        properties: {}
-    } as AdminCollection,
-    {
-        slug: "blog-entries", // slug with hyphen, no table → falls back to snake_case "blog_entries"
-        name: "Blog Entries",
-        table: "",
-        properties: {}
-    } as AdminCollection
-];
-
-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 admin 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 admin 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");
-    });
-});
-