@flink-app/github-app-plugin 0.12.1-alpha.38

package/spec/plugin-core.spec.ts

@@ -0,0 +1,258 @@
+/**
+ * Plugin Core Tests
+ *
+ * Tests for plugin factory function and initialization.
+ * Focused tests covering critical functionality:
+ * - Plugin factory validates required options
+ * - Plugin initializes repositories correctly
+ * - Plugin registers handlers conditionally
+ * - Plugin exposes context methods
+ */
+
+import { FlinkApp } from "@flink-app/flink";
+import { Db } from "mongodb";
+import { githubAppPlugin } from "../src/GitHubAppPlugin";
+import { GitHubAppPluginOptions } from "../src/GitHubAppPluginOptions";
+
+describe("Plugin Core", () => {
+    let mockApp: any;
+    let mockDb: any;
+    let mockCollection: any;
+
+    // Valid test RSA private key (PKCS#1 format, Base64 encoded)
+    const testPrivateKeyBase64 =
+        "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";
+
+    beforeEach(() => {
+        // Mock collection with all necessary MongoDB methods
+        mockCollection = {
+            createIndex: jasmine.createSpy("createIndex").and.returnValue(Promise.resolve("index_name")),
+            insertOne: jasmine.createSpy("insertOne").and.returnValue(Promise.resolve({ insertedId: "mock-id" })),
+            findOne: jasmine.createSpy("findOne").and.returnValue(Promise.resolve(null)),
+            updateOne: jasmine.createSpy("updateOne").and.returnValue(Promise.resolve({ modifiedCount: 1 })),
+            deleteOne: jasmine.createSpy("deleteOne").and.returnValue(Promise.resolve({ deletedCount: 1 })),
+            find: jasmine.createSpy("find").and.returnValue({
+                toArray: jasmine.createSpy("toArray").and.returnValue(Promise.resolve([])),
+            }),
+        };
+
+        // Mock database
+        mockDb = {
+            collection: jasmine.createSpy("collection").and.returnValue(mockCollection),
+        } as unknown as Db;
+
+        // Mock FlinkApp with ctx
+        mockApp = {
+            ctx: {
+                repos: {},
+            },
+            addRepo: jasmine.createSpy("addRepo").and.callFake((name: string, repo: any) => {
+                mockApp.ctx.repos[name] = repo;
+            }),
+            addHandler: jasmine.createSpy("addHandler"),
+        } as unknown as FlinkApp<any>;
+    });
+
+    describe("Plugin Factory Validation", () => {
+        it("should throw error if appId is missing", () => {
+            const invalidOptions = {
+                privateKey: testPrivateKeyBase64,
+                webhookSecret: "test-secret",
+                clientId: "test-client-id",
+                clientSecret: "test-client-secret",
+                onInstallationSuccess: async () => ({ userId: "test", redirectUrl: "/" }),
+            } as any;
+
+            expect(() => githubAppPlugin(invalidOptions)).toThrowError(/appId is required/);
+        });
+
+        it("should throw error if privateKey is missing", () => {
+            const invalidOptions = {
+                appId: "12345",
+                webhookSecret: "test-secret",
+                clientId: "test-client-id",
+                clientSecret: "test-client-secret",
+                onInstallationSuccess: async () => ({ userId: "test", redirectUrl: "/" }),
+            } as any;
+
+            expect(() => githubAppPlugin(invalidOptions)).toThrowError(/privateKey is required/);
+        });
+
+        it("should throw error if onInstallationSuccess callback is missing", () => {
+            const invalidOptions = {
+                appId: "12345",
+                privateKey: testPrivateKeyBase64,
+                webhookSecret: "test-secret",
+                clientId: "test-client-id",
+                clientSecret: "test-client-secret",
+            } as any;
+
+            expect(() => githubAppPlugin(invalidOptions)).toThrowError(/onInstallationSuccess callback is required/);
+        });
+    });
+
+    describe("Plugin Initialization", () => {
+        let validOptions: GitHubAppPluginOptions;
+
+        beforeEach(() => {
+            validOptions = {
+                appId: "12345",
+                appSlug: "test-app",
+                privateKey: testPrivateKeyBase64,
+                webhookSecret: "test-webhook-secret",
+                clientId: "test-client-id",
+                clientSecret: "test-client-secret",
+                onInstallationSuccess: async () => ({ userId: "test-user", redirectUrl: "/dashboard" }),
+            };
+        });
+
+        it("should initialize plugin successfully with valid options", async () => {
+            const plugin = githubAppPlugin(validOptions);
+
+            expect(plugin).toBeDefined();
+            expect(plugin.id).toBe("githubApp");
+            expect(plugin.init).toBeDefined();
+            expect(plugin.ctx).toBeDefined();
+        });
+
+        it("should initialize repositories when init is called", async () => {
+            const plugin = githubAppPlugin(validOptions);
+            await plugin.init!(mockApp, mockDb);
+
+            // Verify addRepo was called for session and installation repos
+            expect(mockApp.addRepo).toHaveBeenCalledTimes(2);
+            expect(mockApp.addRepo).toHaveBeenCalledWith("githubAppSessionRepo", jasmine.any(Object));
+            expect(mockApp.addRepo).toHaveBeenCalledWith("githubInstallationRepo", jasmine.any(Object));
+        });
+
+        it("should register only callback and webhook handlers when registerRoutes is true (default)", async () => {
+            const plugin = githubAppPlugin(validOptions);
+            await plugin.init!(mockApp, mockDb);
+
+            // Verify only 2 handlers were registered (callback and webhook, NOT initiate and uninstall)
+            expect(mockApp.addHandler).toHaveBeenCalledTimes(2);
+        });
+
+        it("should NOT register handlers when registerRoutes is false", async () => {
+            const optionsWithoutRoutes = {
+                ...validOptions,
+                registerRoutes: false,
+            };
+
+            const plugin = githubAppPlugin(optionsWithoutRoutes);
+            await plugin.init!(mockApp, mockDb);
+
+            // Verify handlers were NOT registered
+            expect(mockApp.addHandler).not.toHaveBeenCalled();
+        });
+
+        it("should create TTL indexes for sessions", async () => {
+            const plugin = githubAppPlugin(validOptions);
+            await plugin.init!(mockApp, mockDb);
+
+            // Verify createIndex was called for sessions TTL
+            expect(mockDb.collection).toHaveBeenCalledWith("github_app_sessions");
+            expect(mockCollection.createIndex).toHaveBeenCalledWith(
+                { createdAt: 1 },
+                { expireAfterSeconds: 600 } // default sessionTTL
+            );
+        });
+
+        it("should expose initiateInstallation context method", async () => {
+            const plugin = githubAppPlugin(validOptions);
+            await plugin.init!(mockApp, mockDb);
+
+            expect(plugin.ctx.initiateInstallation).toBeDefined();
+            expect(typeof plugin.ctx.initiateInstallation).toBe("function");
+        });
+
+        it("should expose uninstall context method", async () => {
+            const plugin = githubAppPlugin(validOptions);
+            await plugin.init!(mockApp, mockDb);
+
+            expect(plugin.ctx.uninstall).toBeDefined();
+            expect(typeof plugin.ctx.uninstall).toBe("function");
+        });
+    });
+
+    describe("Context Methods", () => {
+        let validOptions: GitHubAppPluginOptions;
+        let plugin: any;
+
+        beforeEach(async () => {
+            validOptions = {
+                appId: "12345",
+                appSlug: "test-app",
+                privateKey: testPrivateKeyBase64,
+                webhookSecret: "test-webhook-secret",
+                clientId: "test-client-id",
+                clientSecret: "test-client-secret",
+                onInstallationSuccess: async () => ({ userId: "test-user", redirectUrl: "/dashboard" }),
+            };
+
+            plugin = githubAppPlugin(validOptions);
+            await plugin.init!(mockApp, mockDb);
+        });
+
+        describe("initiateInstallation", () => {
+            it("should generate state and return installation URL", async () => {
+                const result = await plugin.ctx.initiateInstallation({
+                    userId: "user-123",
+                    metadata: { source: "settings" },
+                });
+
+                expect(result).toBeDefined();
+                expect(result.redirectUrl).toContain("https://github.com/apps/test-app/installations/new");
+                expect(result.redirectUrl).toContain("state=");
+                expect(result.state).toBeDefined();
+                expect(result.sessionId).toBeDefined();
+            });
+
+            it("should throw error if appSlug is not configured", async () => {
+                const optionsWithoutSlug = {
+                    ...validOptions,
+                    appSlug: undefined,
+                };
+
+                const pluginWithoutSlug = githubAppPlugin(optionsWithoutSlug as any);
+                await pluginWithoutSlug.init!(mockApp, mockDb);
+
+                await expectAsync(
+                    pluginWithoutSlug.ctx.initiateInstallation({
+                        userId: "user-123",
+                    })
+                ).toBeRejectedWithError(/appSlug is required/);
+            });
+        });
+
+        describe("uninstall", () => {
+            it("should return error if installation not found", async () => {
+                // Mock repo to return null
+                const mockInstallationRepo = mockApp.ctx.repos.githubInstallationRepo;
+                spyOn(mockInstallationRepo, "findByUserAndInstallationId").and.returnValue(Promise.resolve(null));
+
+                const result = await plugin.ctx.uninstall({
+                    userId: "user-123",
+                    installationId: 12345,
+                });
+
+                expect(result.success).toBe(false);
+                expect(result.error).toBe("installation-not-found");
+            });
+
+            it("should return error if user doesn't own installation", async () => {
+                // Mock repo to return installation owned by different user
+                const mockInstallationRepo = mockApp.ctx.repos.githubInstallationRepo;
+                spyOn(mockInstallationRepo, "findByUserAndInstallationId").and.returnValue(Promise.resolve({ userId: "other-user", installationId: 12345 }));
+
+                const result = await plugin.ctx.uninstall({
+                    userId: "user-123",
+                    installationId: 12345,
+                });
+
+                expect(result.success).toBe(false);
+                expect(result.error).toBe("installation-not-owned");
+            });
+        });
+    });
+});

package/spec/project-setup.spec.ts

@@ -0,0 +1,56 @@
+/**
+ * Project Setup Tests
+ * Tests for Task 1.1: Verify basic project structure and compilation
+ */
+
+import { githubAppPlugin } from '../src/index';
+import type { GitHubAppPluginOptions, GitHubAppPluginContext } from '../src/index';
+
+describe('GitHub App Plugin - Project Setup', () => {
+  describe('Package Exports', () => {
+    it('should export githubAppPlugin factory function', () => {
+      expect(typeof githubAppPlugin).toBe('function');
+    });
+
+    it('should export GitHubAppPluginOptions type', () => {
+      // Type test - if this compiles, the type exists
+      const options: GitHubAppPluginOptions = {
+        appId: 'test',
+        privateKey: 'test',
+        webhookSecret: 'test',
+        clientId: 'test',
+        clientSecret: 'test',
+        onInstallationSuccess: async () => ({ userId: 'test', redirectUrl: '/' }),
+      };
+      expect(options).toBeDefined();
+    });
+
+    it('should export GitHubAppPluginContext type', () => {
+      // Type test - if this compiles, the type exists
+      // GitHubAppPluginContext has a githubApp property with methods
+      const context: Partial<GitHubAppPluginContext> = {
+        githubApp: {} as any,
+      };
+      expect(context).toBeDefined();
+    });
+  });
+
+  describe('Plugin Factory', () => {
+    it('should create a plugin instance with required options', () => {
+      const plugin = githubAppPlugin({
+        appId: 'test-app-id',
+        privateKey: 'LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQp0ZXN0Ci0tLS0tRU5EIFJTQSBQUklWQVRFIEtFWS0tLS0t', // Base64 encoded
+        webhookSecret: 'test-webhook-secret',
+        clientId: 'test-client-id',
+        clientSecret: 'test-client-secret',
+        onInstallationSuccess: async () => ({ userId: 'test', redirectUrl: '/' }),
+      });
+
+      expect(plugin).toBeDefined();
+      expect(plugin.id).toBe('githubApp');
+      expect(plugin.db).toBeDefined();
+      expect(plugin.db?.useHostDb).toBe(true);
+      expect(typeof plugin.init).toBe('function');
+    });
+  });
+});

package/spec/repos-and-schemas.spec.ts

@@ -0,0 +1,288 @@
+import { FlinkApp } from "@flink-app/flink";
+import { MongoMemoryServer } from "mongodb-memory-server";
+import GitHubAppSessionRepo from "../src/repos/GitHubAppSessionRepo";
+import GitHubInstallationRepo from "../src/repos/GitHubInstallationRepo";
+import GitHubWebhookEventRepo from "../src/repos/GitHubWebhookEventRepo";
+import GitHubAppSession from "../src/schemas/GitHubAppSession";
+import GitHubInstallation from "../src/schemas/GitHubInstallation";
+import WebhookEvent from "../src/schemas/WebhookEvent";
+
+describe("Repos and Schemas", () => {
+    let mongoServer: MongoMemoryServer;
+    let app: FlinkApp<any>;
+    let sessionRepo: GitHubAppSessionRepo;
+    let installationRepo: GitHubInstallationRepo;
+    let webhookEventRepo: GitHubWebhookEventRepo;
+
+    beforeAll(async () => {
+        mongoServer = await MongoMemoryServer.create();
+        const mongoUri = mongoServer.getUri();
+
+        app = new FlinkApp({
+            name: "Test App",
+            port: 3340,
+            db: {
+                uri: mongoUri,
+            },
+        });
+
+        await app.start();
+
+        // Ensure db is defined before instantiating repos
+        if (!app.db) {
+            throw new Error("Database not initialized");
+        }
+
+        // Manually instantiate repos for testing
+        sessionRepo = new GitHubAppSessionRepo(app.ctx, app.db);
+        installationRepo = new GitHubInstallationRepo(app.ctx, app.db);
+        webhookEventRepo = new GitHubWebhookEventRepo(app.ctx, app.db);
+    });
+
+    afterAll(async () => {
+        await app.stop();
+        await mongoServer.stop();
+    });
+
+    afterEach(async () => {
+        // Clean up test data after each test
+        await sessionRepo.collection.deleteMany({});
+        await installationRepo.collection.deleteMany({});
+        await webhookEventRepo.collection.deleteMany({});
+    });
+
+    describe("GitHubAppSessionRepo", () => {
+        it("should create and find session by sessionId", async () => {
+            const session: GitHubAppSession = {
+                sessionId: "test-session-123",
+                state: "test-state-abc",
+                userId: "user-456",
+                metadata: { test: true },
+                createdAt: new Date(),
+            };
+
+            const created = await sessionRepo.create(session);
+            expect(created._id).toBeDefined();
+
+            const found = await sessionRepo.findBySessionId("test-session-123");
+            expect(found).not.toBeNull();
+            expect(found?.sessionId).toBe("test-session-123");
+            expect(found?.state).toBe("test-state-abc");
+            expect(found?.userId).toBe("user-456");
+        });
+
+        it("should delete session by sessionId", async () => {
+            const session: GitHubAppSession = {
+                sessionId: "delete-test",
+                state: "state-xyz",
+                createdAt: new Date(),
+            };
+
+            await sessionRepo.create(session);
+            const deletedCount = await sessionRepo.deleteBySessionId("delete-test");
+            expect(deletedCount).toBe(1);
+
+            const found = await sessionRepo.findBySessionId("delete-test");
+            expect(found).toBeNull();
+        });
+    });
+
+    describe("GitHubInstallationRepo", () => {
+        it("should create and find installation by userId", async () => {
+            const installation: GitHubInstallation = {
+                userId: "user-123",
+                installationId: 12345,
+                accountId: 67890,
+                accountLogin: "testuser",
+                accountType: "User",
+                avatarUrl: "https://example.com/avatar.png",
+                repositories: [
+                    {
+                        id: 1,
+                        name: "repo1",
+                        fullName: "testuser/repo1",
+                        private: false,
+                    },
+                ],
+                permissions: { contents: "read", issues: "write" },
+                events: ["push", "pull_request"],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+
+            const created = await installationRepo.create(installation);
+            expect(created._id).toBeDefined();
+
+            const found = await installationRepo.findByUserId("user-123");
+            expect(found.length).toBe(1);
+            expect(found[0].installationId).toBe(12345);
+            expect(found[0].accountLogin).toBe("testuser");
+        });
+
+        it("should find installation by installationId", async () => {
+            const installation: GitHubInstallation = {
+                userId: "user-456",
+                installationId: 99999,
+                accountId: 11111,
+                accountLogin: "orguser",
+                accountType: "Organization",
+                repositories: [],
+                permissions: {},
+                events: [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+
+            await installationRepo.create(installation);
+
+            const found = await installationRepo.findByInstallationId(99999);
+            expect(found).not.toBeNull();
+            expect(found?.installationId).toBe(99999);
+            expect(found?.accountType).toBe("Organization");
+        });
+
+        it("should update repositories for an installation", async () => {
+            const installation: GitHubInstallation = {
+                userId: "user-789",
+                installationId: 55555,
+                accountId: 22222,
+                accountLogin: "testorg",
+                accountType: "Organization",
+                repositories: [
+                    {
+                        id: 1,
+                        name: "old-repo",
+                        fullName: "testorg/old-repo",
+                        private: true,
+                    },
+                ],
+                permissions: {},
+                events: [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+
+            await installationRepo.create(installation);
+
+            const newRepos = [
+                {
+                    id: 2,
+                    name: "new-repo",
+                    fullName: "testorg/new-repo",
+                    private: false,
+                },
+                {
+                    id: 3,
+                    name: "another-repo",
+                    fullName: "testorg/another-repo",
+                    private: true,
+                },
+            ];
+
+            const updated = await installationRepo.updateRepositories(55555, newRepos);
+            expect(updated).not.toBeNull();
+            expect(updated?.repositories.length).toBe(2);
+            expect(updated?.repositories[0].name).toBe("new-repo");
+        });
+
+        it("should suspend an installation", async () => {
+            const installation: GitHubInstallation = {
+                userId: "user-suspend",
+                installationId: 77777,
+                accountId: 33333,
+                accountLogin: "suspendtest",
+                accountType: "User",
+                repositories: [],
+                permissions: {},
+                events: [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+
+            await installationRepo.create(installation);
+
+            const suspendedBy = { id: 999, login: "admin" };
+            const suspended = await installationRepo.suspend(77777, suspendedBy);
+
+            expect(suspended).not.toBeNull();
+            expect(suspended?.suspendedAt).toBeDefined();
+            expect(suspended?.suspendedBy?.login).toBe("admin");
+        });
+
+        it("should delete installation by installationId", async () => {
+            const installation: GitHubInstallation = {
+                userId: "user-delete",
+                installationId: 88888,
+                accountId: 44444,
+                accountLogin: "deletetest",
+                accountType: "User",
+                repositories: [],
+                permissions: {},
+                events: [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+
+            await installationRepo.create(installation);
+
+            const deletedCount = await installationRepo.deleteByInstallationId(88888);
+            expect(deletedCount).toBe(1);
+
+            const found = await installationRepo.findByInstallationId(88888);
+            expect(found).toBeNull();
+        });
+    });
+
+    describe("GitHubWebhookEventRepo", () => {
+        it("should find unprocessed webhook events", async () => {
+            const event1: WebhookEvent = {
+                installationId: 12345,
+                event: "push",
+                action: "created",
+                deliveryId: "delivery-1",
+                payload: { test: "data1" },
+                processed: false,
+                createdAt: new Date(),
+            };
+
+            const event2: WebhookEvent = {
+                installationId: 12345,
+                event: "pull_request",
+                action: "opened",
+                deliveryId: "delivery-2",
+                payload: { test: "data2" },
+                processed: true,
+                processedAt: new Date(),
+                createdAt: new Date(),
+            };
+
+            await webhookEventRepo.create(event1);
+            await webhookEventRepo.create(event2);
+
+            const unprocessed = await webhookEventRepo.findUnprocessed();
+            expect(unprocessed.length).toBe(1);
+            expect(unprocessed[0].event).toBe("push");
+            expect(unprocessed[0].processed).toBe(false);
+        });
+
+        it("should mark event as processed", async () => {
+            const event: WebhookEvent = {
+                installationId: 67890,
+                event: "installation",
+                action: "created",
+                deliveryId: "delivery-3",
+                payload: { installation: { id: 67890 } },
+                processed: false,
+                createdAt: new Date(),
+            };
+
+            const created = await webhookEventRepo.create(event);
+            expect(created._id).toBeDefined();
+
+            const marked = await webhookEventRepo.markProcessed(created._id!);
+            expect(marked).not.toBeNull();
+            expect(marked?.processed).toBe(true);
+            expect(marked?.processedAt).toBeDefined();
+        });
+    });
+});