@rebasepro/server-core 0.4.0 → 0.6.0

package/test/graphql-schema-generator.test.ts

@@ -0,0 +1,554 @@
+import { GraphQLSchemaGenerator } from "../src/api/graphql/graphql-schema-generator";
+import { DataDriver } from "../../types/src/controllers/data_driver";
+import { EntityCollection } from "../../types/src/types/collections";
+import {
+    GraphQLSchema,
+    GraphQLObjectType,
+    GraphQLNonNull,
+    GraphQLString,
+    GraphQLFloat,
+    GraphQLBoolean,
+    GraphQLList,
+    GraphQLInputObjectType,
+    graphql,
+    printSchema
+} from "graphql";
+
+describe("GraphQLSchemaGenerator", () => {
+    let mockDriver: jest.Mocked<DataDriver>;
+    let collections: EntityCollection[];
+
+    beforeEach(() => {
+        mockDriver = {
+            key: "postgres",
+            initialised: true,
+            fetchCollection: jest.fn(),
+            listenCollection: jest.fn(),
+            fetchEntity: jest.fn(),
+            listenEntity: jest.fn(),
+            saveEntity: jest.fn(),
+            deleteEntity: jest.fn(),
+            checkUniqueField: jest.fn(),
+            countEntities: jest.fn(),
+            withAuth: jest.fn(),
+            admin: {} as any
+        } as unknown as jest.Mocked<DataDriver>;
+
+        collections = [
+            {
+                slug: "posts",
+                name: "Posts",
+                singularName: "Post",
+                description: "Blog posts",
+                properties: {
+                    title: { name: "Title",
+type: "string",
+validation: { required: true } },
+                    body: { name: "Body",
+type: "string" },
+                    views: { name: "Views",
+type: "number" },
+                    published: { name: "Published",
+type: "boolean" },
+                    createdAt: { name: "Created At",
+type: "date" }
+                }
+            } as unknown as EntityCollection,
+            {
+                slug: "authors",
+                name: "Authors",
+                singularName: "Author",
+                properties: {
+                    name: { name: "Name",
+type: "string",
+validation: { required: true } },
+                    bio: { name: "Bio",
+type: "string" }
+                }
+            } as unknown as EntityCollection
+        ];
+    });
+
+    // ─── Schema Generation ──────────────────────────────────────────
+
+    describe("generateSchema", () => {
+        it("returns a valid GraphQLSchema", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            expect(schema).toBeInstanceOf(GraphQLSchema);
+        });
+
+        it("creates Query and Mutation root types", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            expect(schema.getQueryType()).toBeDefined();
+            expect(schema.getMutationType()).toBeDefined();
+        });
+
+        it("generates a printable SDL without errors", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const sdl = printSchema(schema);
+            expect(sdl).toContain("type Post");
+            expect(sdl).toContain("type Author");
+            expect(sdl).toContain("type Query");
+            expect(sdl).toContain("type Mutation");
+        });
+    });
+
+    // ─── Entity Types ───────────────────────────────────────────────
+
+    describe("entity types", () => {
+        it("creates an object type for each collection", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const typeMap = schema.getTypeMap();
+            expect(typeMap["Post"]).toBeInstanceOf(GraphQLObjectType);
+            expect(typeMap["Author"]).toBeInstanceOf(GraphQLObjectType);
+        });
+
+        it("generates an id field as NonNull String", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const postType = schema.getType("Post") as GraphQLObjectType;
+            const fields = postType.getFields();
+            expect(fields.id).toBeDefined();
+            expect(fields.id.type).toBeInstanceOf(GraphQLNonNull);
+            expect((fields.id.type as GraphQLNonNull<any>).ofType).toBe(GraphQLString);
+        });
+
+        it("maps string properties to GraphQLString", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const postType = schema.getType("Post") as GraphQLObjectType;
+            const bodyField = postType.getFields().body;
+            expect(bodyField.type).toBe(GraphQLString);
+        });
+
+        it("maps number properties to GraphQLFloat", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const postType = schema.getType("Post") as GraphQLObjectType;
+            const viewsField = postType.getFields().views;
+            expect(viewsField.type).toBe(GraphQLFloat);
+        });
+
+        it("maps boolean properties to GraphQLBoolean", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const postType = schema.getType("Post") as GraphQLObjectType;
+            const publishedField = postType.getFields().published;
+            expect(publishedField.type).toBe(GraphQLBoolean);
+        });
+
+        it("maps date properties to GraphQLString", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const postType = schema.getType("Post") as GraphQLObjectType;
+            const createdAtField = postType.getFields().createdAt;
+            // Date is non-null because the original property definition doesn't set required,
+            // so it should be nullable GraphQLString
+            expect(createdAtField).toBeDefined();
+        });
+
+        it("wraps required properties in NonNull", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const postType = schema.getType("Post") as GraphQLObjectType;
+            const titleField = postType.getFields().title;
+            expect(titleField.type).toBeInstanceOf(GraphQLNonNull);
+        });
+
+        it("skips relation properties from entity fields", () => {
+            const withRelation: EntityCollection[] = [
+                {
+                    slug: "comments",
+                    name: "Comments",
+                    singularName: "Comment",
+                    properties: {
+                        text: { name: "Text",
+type: "string" },
+                        author: { name: "Author",
+type: "relation" }
+                    }
+                } as unknown as EntityCollection
+            ];
+            const generator = new GraphQLSchemaGenerator(withRelation, mockDriver);
+            const schema = generator.generateSchema();
+            const commentType = schema.getType("Comment") as GraphQLObjectType;
+            const fields = commentType.getFields();
+            expect(fields.text).toBeDefined();
+            expect(fields.author).toBeUndefined();
+        });
+    });
+
+    // ─── Input Types ────────────────────────────────────────────────
+
+    describe("input types", () => {
+        it("creates input types for each collection", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const typeMap = schema.getTypeMap();
+            expect(typeMap["PostInput"]).toBeInstanceOf(GraphQLInputObjectType);
+            expect(typeMap["AuthorInput"]).toBeInstanceOf(GraphQLInputObjectType);
+        });
+
+        it("input types skip relation properties", () => {
+            const withRelation: EntityCollection[] = [
+                {
+                    slug: "comments",
+                    name: "Comments",
+                    singularName: "Comment",
+                    properties: {
+                        text: { name: "Text",
+type: "string" },
+                        post: { name: "Post",
+type: "relation" }
+                    }
+                } as unknown as EntityCollection
+            ];
+            const generator = new GraphQLSchemaGenerator(withRelation, mockDriver);
+            const schema = generator.generateSchema();
+            const inputType = schema.getType("CommentInput") as GraphQLInputObjectType;
+            const fields = inputType.getFields();
+            expect(fields.text).toBeDefined();
+            expect(fields.post).toBeUndefined();
+        });
+    });
+
+    // ─── Query Resolvers ────────────────────────────────────────────
+
+    describe("query resolvers", () => {
+        it("creates single-entity and list queries for each collection", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const queryType = schema.getQueryType()!;
+            const fields = queryType.getFields();
+
+            // Single entity queries (lowercase singular name)
+            expect(fields.post).toBeDefined();
+            expect(fields.author).toBeDefined();
+
+            // List queries (slug)
+            expect(fields.posts).toBeDefined();
+            expect(fields.authors).toBeDefined();
+        });
+
+        it("single-entity query calls fetchEntity with correct args", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            const mockEntity = {
+                id: "1",
+                path: "posts",
+                values: { title: "Hello World",
+body: "Content" }
+            };
+            mockDriver.fetchEntity.mockResolvedValue(mockEntity as any);
+
+            const result = await graphql({
+                schema,
+                source: "query { post(id: \"1\") { id title body } }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(mockDriver.fetchEntity).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    path: "posts",
+                    entityId: "1"
+                })
+            );
+        });
+
+        it("list query calls fetchCollection with limit and offset", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            mockDriver.fetchCollection.mockResolvedValue([]);
+
+            const result = await graphql({
+                schema,
+                source: "query { posts(limit: 10, offset: 5) { id title } }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(mockDriver.fetchCollection).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    path: "posts",
+                    limit: 10,
+                    startAfter: "5"
+                })
+            );
+        });
+
+        it("list query parses JSON where filter", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            mockDriver.fetchCollection.mockResolvedValue([]);
+
+            const result = await graphql({
+                schema,
+                source: "query { posts(where: \"{\\\"published\\\": true}\") { id } }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(mockDriver.fetchCollection).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    filter: { published: true }
+                })
+            );
+        });
+
+        it("list query rejects invalid JSON where filter", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            const result = await graphql({
+                schema,
+                source: "query { posts(where: \"not-json\") { id } }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeDefined();
+            expect(result.errors![0].message).toContain("Invalid 'where' filter");
+        });
+
+        it("list query rejects non-object JSON where filter", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            const result = await graphql({
+                schema,
+                source: "query { posts(where: \"[1,2,3]\") { id } }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeDefined();
+            expect(result.errors![0].message).toContain("Filter must be a JSON object");
+        });
+    });
+
+    // ─── Mutation Resolvers ─────────────────────────────────────────
+
+    describe("mutation resolvers", () => {
+        it("creates create, update, and delete mutations for each collection", () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+            const mutationType = schema.getMutationType()!;
+            const fields = mutationType.getFields();
+
+            expect(fields.createPost).toBeDefined();
+            expect(fields.updatePost).toBeDefined();
+            expect(fields.deletePost).toBeDefined();
+            expect(fields.createAuthor).toBeDefined();
+            expect(fields.updateAuthor).toBeDefined();
+            expect(fields.deleteAuthor).toBeDefined();
+        });
+
+        it("create mutation calls saveEntity with status 'new'", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            const mockEntity = {
+                id: "1",
+                path: "posts",
+                values: { title: "New Post" }
+            };
+            mockDriver.saveEntity.mockResolvedValue(mockEntity as any);
+
+            const result = await graphql({
+                schema,
+                source: "mutation { createPost(input: { title: \"New Post\" }) { id } }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(mockDriver.saveEntity).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    path: "posts",
+                    values: { title: "New Post" },
+                    status: "new"
+                })
+            );
+        });
+
+        it("update mutation calls saveEntity with status 'existing' and entityId", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            const mockEntity = {
+                id: "1",
+                path: "posts",
+                values: { title: "Updated" }
+            };
+            mockDriver.saveEntity.mockResolvedValue(mockEntity as any);
+
+            const result = await graphql({
+                schema,
+                source: "mutation { updatePost(id: \"1\", input: { title: \"Updated\" }) { id } }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(mockDriver.saveEntity).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    path: "posts",
+                    entityId: "1",
+                    values: { title: "Updated" },
+                    status: "existing"
+                })
+            );
+        });
+
+        it("delete mutation returns true on success", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            const mockEntity = { id: "1",
+path: "posts",
+values: {} };
+            mockDriver.fetchEntity.mockResolvedValue(mockEntity as any);
+            mockDriver.deleteEntity.mockResolvedValue(undefined);
+
+            const result = await graphql({
+                schema,
+                source: "mutation { deletePost(id: \"1\") }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(result.data?.deletePost).toBe(true);
+            expect(mockDriver.deleteEntity).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    entity: mockEntity
+                })
+            );
+        });
+
+        it("delete mutation returns false when entity not found", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            mockDriver.fetchEntity.mockResolvedValue(undefined as any);
+
+            const result = await graphql({
+                schema,
+                source: "mutation { deletePost(id: \"nonexistent\") }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(result.data?.deletePost).toBe(false);
+        });
+
+        it("delete mutation returns false when deleteEntity throws", async () => {
+            const generator = new GraphQLSchemaGenerator(collections, mockDriver);
+            const schema = generator.generateSchema();
+
+            const mockEntity = { id: "1",
+path: "posts",
+values: {} };
+            mockDriver.fetchEntity.mockResolvedValue(mockEntity as any);
+            mockDriver.deleteEntity.mockRejectedValue(new Error("DB error"));
+
+            const result = await graphql({
+                schema,
+                source: "mutation { deletePost(id: \"1\") }",
+                contextValue: { driver: mockDriver }
+            });
+
+            expect(result.errors).toBeUndefined();
+            expect(result.data?.deletePost).toBe(false);
+        });
+    });
+
+    // ─── Edge Cases ─────────────────────────────────────────────────
+
+    describe("edge cases", () => {
+        it("handles empty collections array", () => {
+            const generator = new GraphQLSchemaGenerator([], mockDriver);
+            const schema = generator.generateSchema();
+            expect(schema).toBeInstanceOf(GraphQLSchema);
+        });
+
+        it("handles collection with array property", () => {
+            const arrayCollection: EntityCollection[] = [
+                {
+                    slug: "tags",
+                    name: "Tags",
+                    singularName: "Tag",
+                    properties: {
+                        labels: { name: "Labels",
+type: "array" }
+                    }
+                } as unknown as EntityCollection
+            ];
+            const generator = new GraphQLSchemaGenerator(arrayCollection, mockDriver);
+            const schema = generator.generateSchema();
+            const tagType = schema.getType("Tag") as GraphQLObjectType;
+            const labelsField = tagType.getFields().labels;
+            expect(labelsField.type).toBeInstanceOf(GraphQLList);
+        });
+
+        it("handles collection with vector property", () => {
+            const vectorCollection: EntityCollection[] = [
+                {
+                    slug: "embeddings",
+                    name: "Embeddings",
+                    singularName: "Embedding",
+                    properties: {
+                        embedding: { name: "Embedding",
+type: "vector" }
+                    }
+                } as unknown as EntityCollection
+            ];
+            const generator = new GraphQLSchemaGenerator(vectorCollection, mockDriver);
+            const schema = generator.generateSchema();
+            const embeddingType = schema.getType("Embedding") as GraphQLObjectType;
+            const embeddingField = embeddingType.getFields().embedding;
+            expect(embeddingField.type).toBeInstanceOf(GraphQLList);
+        });
+
+        it("handles collection with binary property", () => {
+            const binaryCollection: EntityCollection[] = [
+                {
+                    slug: "files",
+                    name: "Files",
+                    singularName: "File",
+                    properties: {
+                        data: { name: "Data",
+type: "binary" }
+                    }
+                } as unknown as EntityCollection
+            ];
+            const generator = new GraphQLSchemaGenerator(binaryCollection, mockDriver);
+            const schema = generator.generateSchema();
+            const fileType = schema.getType("File") as GraphQLObjectType;
+            const dataField = fileType.getFields().data;
+            expect(dataField.type).toBe(GraphQLString);
+        });
+
+        it("deduplicates types when generateSchema is called", () => {
+            const dupeCollections: EntityCollection[] = [
+                {
+                    slug: "items",
+                    name: "Items",
+                    singularName: "Item",
+                    properties: {
+                        name: { name: "Name",
+type: "string" }
+                    }
+                } as unknown as EntityCollection
+            ];
+            const generator = new GraphQLSchemaGenerator(dupeCollections, mockDriver);
+            // Calling generateSchema should not throw even if types are created internally multiple times
+            const schema = generator.generateSchema();
+            expect(schema.getType("Item")).toBeDefined();
+            expect(schema.getType("ItemInput")).toBeDefined();
+        });
+    });
+});

package/test/jwt-security.test.ts

@@ -66,7 +66,7 @@ refreshExpiresIn: "30d" });
 
         it("throws when secret is not configured", () => {
             // Force empty secret
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
+
             Object.defineProperty(require("../src/auth/jwt"), "jwtConfig", { value: { secret: "" },
 writable: true });
             // This won't work since jwtConfig is module-scoped, but generateAccessToken has its own check

package/test/query-parser.test.ts

@@ -157,7 +157,6 @@ describe("parseQueryOptions — PostgREST filters", () => {
 });
 
 
-
 // ─────────────────────────────────────────────────────────────
 // parseQueryOptions — Sorting
 // ─────────────────────────────────────────────────────────────

package/test/reset-password-admin.test.ts

@@ -0,0 +1,113 @@
+import { Hono } from "hono";
+import { createResetPasswordRoute } from "../src/auth/reset-password-admin";
+import type { AuthRepository } from "../src/auth/interfaces";
+import { configureJwt, generateAccessToken } from "../src/auth/jwt";
+import { errorHandler } from "../src/api/errors";
+
+const TEST_SECRET = "integration-test-secret-key-that-is-definitely-32-chars-long!!";
+
+describe("createResetPasswordRoute & onAdminResetPassword", () => {
+    let mockAuthRepo: jest.Mocked<AuthRepository>;
+    let mockEmailService: { send: jest.Mock; isConfigured: jest.Mock };
+
+    beforeAll(() => {
+        configureJwt({ secret: TEST_SECRET,
+accessExpiresIn: "1h" });
+    });
+
+    beforeEach(() => {
+        mockAuthRepo = {
+            getUserById: jest.fn(),
+            getUserRoleIds: jest.fn().mockResolvedValue(["admin"]),
+            updatePassword: jest.fn().mockResolvedValue(undefined),
+            createPasswordResetToken: jest.fn().mockResolvedValue(undefined)
+        } as unknown as jest.Mocked<AuthRepository>;
+
+        mockEmailService = {
+            send: jest.fn().mockResolvedValue(undefined),
+            isConfigured: jest.fn().mockReturnValue(true)
+        };
+    });
+
+    function createApp(authHooks?: any) {
+        const app = new Hono();
+        app.onError(errorHandler);
+        const adminRoutes = createResetPasswordRoute({
+            authRepo: mockAuthRepo,
+            emailService: mockEmailService as any,
+            emailConfig: {
+                from: "test@example.com",
+                resetPasswordUrl: "https://reset.com"
+            },
+            authHooks
+        });
+        app.route("/api/admin", adminRoutes);
+        return app;
+    }
+
+    it("falls back to default password reset logic when no hook is provided", async () => {
+        mockAuthRepo.getUserById.mockResolvedValue({
+            id: "user-123",
+            email: "user@example.com",
+            displayName: "User One"
+        } as any);
+
+        const app = createApp();
+        const adminToken = generateAccessToken("admin-user", ["admin"]);
+
+        const res = await app.request("/api/admin/users/user-123/reset-password", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${adminToken}`
+            }
+        });
+
+        expect(res.status).toBe(200);
+        const body = await res.json() as any;
+        expect(body.invitationSent).toBe(true);
+        expect(body.user.uid).toBe("user-123");
+        expect(mockAuthRepo.createPasswordResetToken).toHaveBeenCalled();
+        expect(mockEmailService.send).toHaveBeenCalled();
+    });
+
+    it("calls onAdminResetPassword hook when provided", async () => {
+        mockAuthRepo.getUserById.mockResolvedValue({
+            id: "user-123",
+            email: "user@example.com",
+            displayName: "User One"
+        } as any);
+
+        const onAdminResetPasswordMock = jest.fn().mockResolvedValue({
+            temporaryPassword: "hook-temp-password",
+            invitationSent: false
+        });
+
+        const app = createApp({
+            onAdminResetPassword: onAdminResetPasswordMock
+        });
+        const adminToken = generateAccessToken("admin-user", ["admin"]);
+
+        const res = await app.request("/api/admin/users/user-123/reset-password", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${adminToken}`
+            }
+        });
+
+        expect(res.status).toBe(200);
+        const body = await res.json() as any;
+        expect(body.invitationSent).toBe(false);
+        expect(body.temporaryPassword).toBe("hook-temp-password");
+        expect(body.user.uid).toBe("user-123");
+
+        expect(onAdminResetPasswordMock).toHaveBeenCalledWith(
+            "user-123",
+            expect.objectContaining({
+                authRepo: mockAuthRepo,
+                emailService: mockEmailService
+            })
+        );
+        expect(mockAuthRepo.createPasswordResetToken).not.toHaveBeenCalled();
+        expect(mockEmailService.send).not.toHaveBeenCalled();
+    });
+});