Purpose

This is a PR primarily designed to discuss Starbase plugins.

At it's core, the main purpose of Starbase is to query a database, whether that be a DO or external one. Other functionality such as studio, import/export, websockets etc are additional functionality. Currently it's possible to disable/enable this functionality through feature flags... but it's not possible to extend Starbase. Plugins breakout this functionality and allow users to extend Starbase how they see fit.

This PR proposes being able to do the following:

new StarbaseDB({
  dataSource,
  config,
  plugins: [new WebSocketPlugin(), new StudioPlugin({ username: '', password: '', apiKey: '' })],
})

The signature for a function is currently:

export abstract class StarbasePlugin {
    constructor(public name: string) {
        console.log(`Plugin ${name} loaded`)
    }

    public async register(app: StarbaseApp): Promise<void> {
        throw new UnimplementedError('register')
    }
}

If implemented, the register method of a plugin will be called early on in the lifecycle, where app is the Hono app instance - this allows users to add routes, apply middleware etc as they normally would.

This PR also passes the dataSource and config into Hono context, allowing plugins to access (or modify) this. Plugins are applied in-order and have an async register API.

Later on, it may make sense to pass this context (StarbaseContext) around everywhere, rather than dealing with individual function arguments - but one for later.

Other plugins can be created easily (assuming this api is ok) for import, export, litrest, cors, etc.

## Other use-cases

### Auth

There is currently a manual auth template which users would be expected to bind to the worker and call themselves. This could be instead extracted out into a plugin:

new StarbaseAuthPlugin(...)

Hooks

In this PR there is a StarbasePluginRegistry class. The idea here is that we could export useful methods to allow plugin authors to subscribe to events, e.g.

class MyPlugin extends StarbasePlugin {
  override async onBeforeQuery(args) {
    // log, mutate.. whatever!
  }

  override async onAfterQuery(args) {
    // log, mutate.. whatever!
  }
}

By having a registry, we could simply call registry.onBeforeQuery(args) where needed, and internally it'd call every plugins onBeforeQuery method.