sotobot 0.3.2 → 0.4.0

package/README.md

@@ -0,0 +1,53 @@
+# sotobot 🤖
+
+A serverless-focused GitHub bot framework.
+
+> [!WARNING]
+> This project is in early development and will have many breaking changes.
+
+## Install
+
+```sh
+npm install sotobot
+```
+
+## Usage
+
+```ts
+import { createBot, GitHubDriver } from 'sotobot';
+import { createServer } from 'sotobot/cloudflare.js';
+
+const driver = new GitHubDriver({
+  appId: env.APP_ID,
+  privateKey: env.PRIVATE_KEY,
+  webhookSecret: env.WEBHOOK_SECRET,
+});
+
+const bot = createBot({ name: 'soto' }, driver);
+
+bot.addEventListener('botCommand', async (event) => {
+  const { command, args, owner, repo, pullRequestNumber, source } =
+    event.detail;
+
+  if (command !== 'ping') {
+    return;
+  }
+
+  const { octokit } = source;
+  await octokit.request(
+    'POST /repos/{owner}/{repo}/issues/{issue_number}/comments',
+    {
+      owner,
+      repo,
+      issue_number: pullRequestNumber,
+      body: 'pong 🏓',
+    },
+  );
+});
+
+export default createServer(bot);
+```
+
+## License
+
+[MIT](./LICENSE)

package/lib/bot.d.ts

@@ -1,11 +1,30 @@
-import { App } from '@octokit/app';
-import { CommandHandler } from './commands.js';
-export interface BotOptions {
-    name: string;
+import { Driver } from './drivers/types.js';
+import { BotOptions } from './options.js';
+export interface BotCommandEventDetail {
+    bot: Bot;
+    command: string;
+    args: string[];
+    repo: string;
+    owner: string;
+    pullRequestNumber: number;
+    source: unknown;
 }
-export declare class Bot {
+export interface BotEventMap {
+    botCommand: CustomEvent<BotCommandEventDetail>;
+}
+interface BotEventTarget extends EventTarget {
+    addEventListener<TEvent extends keyof BotEventMap>(event: TEvent, listener: (ev: BotEventMap[TEvent]) => void): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+}
+declare const eventTarget: {
+    new (): BotEventTarget;
+    prototype: BotEventTarget;
+};
+export declare class Bot extends eventTarget {
     #private;
-    constructor(app: App, options: BotOptions);
-    addCommand(name: string | string[], fn: CommandHandler): void;
+    get name(): string;
+    get driver(): Driver;
+    constructor(driver: Driver, options: BotOptions);
     handleRequest(request: Request): Promise<Response>;
 }
+export {};

package/lib/bot.js

@@ -1,57 +1,38 @@
-import { createWebMiddleware } from '@octokit/webhooks';
 import { parseCommand } from './comments.js';
-import { WEBHOOK_PATH } from './constants.js';
-import { hasWriteAccess } from './octokit.js';
-export class Bot {
-    #app;
-    #middleware;
-    #commands = new Map();
+const eventTarget = EventTarget;
+export class Bot extends eventTarget {
+    #driver;
     #options;
-    constructor(app, options) {
-        this.#options = options;
-        this.#app = app;
-        this.#app.webhooks.onError(this.#onError);
-        this.#app.webhooks.on('issue_comment.created', this.#onIssueComment);
-        this.#middleware = createWebMiddleware(this.#app.webhooks, {
-            path: WEBHOOK_PATH,
-        });
+    get name() {
+        return this.#options.name;
     }
-    addCommand(name, fn) {
-        if (Array.isArray(name)) {
-            for (const n of name) {
-                this.#commands.set(n, fn);
-            }
-        }
-        else {
-            this.#commands.set(name, fn);
-        }
+    get driver() {
+        return this.#driver;
+    }
+    constructor(driver, options) {
+        super();
+        this.#driver = driver;
+        this.#options = options;
+        this.#driver.addEventListener('pr.commentCreated', this.#onPRCommentCreated);
     }
     handleRequest(request) {
-        return this.#middleware(request);
+        return this.#driver.handleRequest(request);
     }
-    #onIssueComment = async ({ octokit, payload, }) => {
-        if (!payload.issue.pull_request) {
-            return;
-        }
-        const command = parseCommand(this.#options.name, payload.comment.body);
+    #onPRCommentCreated = async (ev) => {
+        const command = parseCommand(this.#options.name, ev.detail.body);
         if (!command) {
             return;
         }
-        const handler = this.#commands.get(command.name);
-        if (!handler) {
-            return;
-        }
-        const username = payload.comment.user?.login;
-        if (!username) {
-            return;
-        }
-        const allowed = await hasWriteAccess(octokit, payload.repository.owner.login, payload.repository.name, username);
-        if (!allowed) {
-            return;
-        }
-        await handler({ octokit, payload, args: command.args });
-    };
-    #onError = (error) => {
-        console.error('Webhook handler error', error);
+        this.dispatchEvent(new CustomEvent('botCommand', {
+            detail: {
+                bot: this,
+                command: command.name,
+                args: command.args,
+                repo: ev.detail.repository,
+                owner: ev.detail.owner,
+                pullRequestNumber: ev.detail.pullRequestNumber,
+                source: ev.detail.raw,
+            },
+        }));
     };
 }

package/lib/cloudflare.d.ts

@@ -1,9 +1,4 @@
 import { Bot } from './bot.js';
-export interface ServerOptions {
-    privateKey: string;
-    appId: string;
-    webhookSecret: string;
-}
 type BotFactory = () => Promise<Bot>;
 export declare function createServer(bot: Bot | BotFactory): {
     fetch(request: Request): Promise<Response>;

package/lib/commands.d.ts

@@ -1,12 +1,10 @@
-import { Octokit } from '@octokit/core';
-import { EmitterWebhookEvent } from '@octokit/webhooks/types';
-type IssueCommentEvent = EmitterWebhookEvent<'issue_comment.created'> & {
-    octokit: Octokit;
-};
+import type { Bot } from './bot.js';
 export interface CommandContext {
-    octokit: Octokit;
-    payload: IssueCommentEvent['payload'];
+    command: string;
+    raw: unknown;
     args: string[];
+    repo: string;
+    owner: string;
+    pullRequestNumber: number | undefined;
 }
-export type CommandHandler = (context: CommandContext) => Promise<void>;
-export {};
+export type CommandHandler = (bot: Bot, context: CommandContext) => Promise<void>;

package/lib/drivers/github.d.ts

@@ -0,0 +1,21 @@
+import type { Octokit } from '@octokit/core';
+import type { HandlerFunction } from '@octokit/webhooks/types';
+import { Driver, PRCommentCreatedEventDetail } from './types.js';
+export interface GitHubDriverOptions {
+    privateKey: string;
+    appId: string;
+    webhookSecret: string;
+}
+type IssueCommentCreatedEvent = Parameters<HandlerFunction<'issue_comment.created', {
+    octokit: Octokit;
+}>>[0];
+export interface GitHubDriverEventMap {
+    error: CustomEvent<unknown>;
+    commentCreated: CustomEvent<PRCommentCreatedEventDetail<IssueCommentCreatedEvent>>;
+}
+export declare class GitHubDriver extends EventTarget implements Driver {
+    #private;
+    constructor(options: GitHubDriverOptions);
+    handleRequest(request: Request): Promise<Response>;
+}
+export {};

package/lib/drivers/github.js

@@ -0,0 +1,55 @@
+import { App } from '@octokit/app';
+import { createWebMiddleware } from '@octokit/webhooks';
+import { WEBHOOK_PATH } from '../constants.js';
+import { hasWriteAccess } from '../octokit.js';
+export class GitHubDriver extends EventTarget {
+    #app;
+    #middleware;
+    constructor(options) {
+        super();
+        const { privateKey, appId, webhookSecret } = options;
+        this.#app = new App({
+            appId,
+            privateKey,
+            webhooks: {
+                secret: webhookSecret,
+            },
+        });
+        this.#app.webhooks.onError(this.#onError);
+        this.#app.webhooks.on('issue_comment.created', this.#onIssueComment);
+        this.#middleware = createWebMiddleware(this.#app.webhooks, {
+            path: WEBHOOK_PATH,
+        });
+    }
+    handleRequest(request) {
+        return this.#middleware(request);
+    }
+    #onIssueComment = async (event) => {
+        const { payload, octokit } = event;
+        if (!payload.issue.pull_request) {
+            return;
+        }
+        const username = payload.comment.user?.login;
+        if (!username) {
+            return;
+        }
+        const allowed = await hasWriteAccess(octokit, payload.repository.owner.login, payload.repository.name, username);
+        if (!allowed) {
+            return;
+        }
+        this.dispatchEvent(new CustomEvent('pr.commentCreated', {
+            detail: {
+                raw: event,
+                body: payload.comment.body || '',
+                repository: payload.repository.name,
+                owner: payload.repository.owner.login,
+                pullRequestNumber: payload.issue.number,
+            },
+        }));
+    };
+    #onError = (error) => {
+        this.dispatchEvent(new CustomEvent('error', {
+            detail: error,
+        }));
+    };
+}

package/lib/drivers/types.d.ts

@@ -0,0 +1,16 @@
+export interface PRCommentCreatedEventDetail<T> {
+    body: string;
+    raw: T;
+    repository: string;
+    owner: string;
+    pullRequestNumber: number;
+}
+export interface DriverEventMap {
+    error: CustomEvent<unknown>;
+    'pr.commentCreated': CustomEvent<PRCommentCreatedEventDetail<unknown>>;
+}
+export interface Driver {
+    handleRequest(request: Request): Promise<Response>;
+    addEventListener<TEvent extends keyof DriverEventMap>(event: TEvent, listener: (ev: DriverEventMap[TEvent]) => void): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+}

package/lib/drivers/types.js

@@ -0,0 +1 @@
+export {};

package/lib/main.d.ts

@@ -1,9 +1,8 @@
-import { Bot, BotOptions } from './bot.js';
-export interface CreateBotOptions {
-    privateKey: string;
-    appId: string;
-    webhookSecret: string;
-    bot: BotOptions;
-}
-export declare function createBot(options: CreateBotOptions): Bot;
+import { Bot } from './bot.js';
+import { BotOptions } from './options.js';
+import { Driver } from './drivers/types.js';
+export declare function createBot(options: BotOptions, driver: Driver): Bot;
+export { Bot, type BotCommandEventDetail, type BotEventMap } from './bot.js';
 export * from './commands.js';
+export * from './drivers/types.js';
+export * from './drivers/github.js';

package/lib/main.js

@@ -1,15 +1,9 @@
-import { App } from '@octokit/app';
 import { Bot } from './bot.js';
-export function createBot(options) {
-    const { privateKey, appId, webhookSecret } = options;
-    const app = new App({
-        appId,
-        privateKey,
-        webhooks: {
-            secret: webhookSecret,
-        },
-    });
-    const bot = new Bot(app, options.bot);
+export function createBot(options, driver) {
+    const bot = new Bot(driver, options);
     return bot;
 }
+export { Bot } from './bot.js';
 export * from './commands.js';
+export * from './drivers/types.js';
+export * from './drivers/github.js';

package/lib/options.d.ts

@@ -0,0 +1,3 @@
+export interface BotOptions {
+    name: string;
+}

package/lib/options.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sotobot",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "A serverless-focused GitHub bot framework.",
   "keywords": [
     "github",