From fa622d35184628594cbfafe6204371eff92e86d5 Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Mon, 23 Feb 2026 18:50:05 +0100 Subject: [PATCH 1/9] feat(appkit): introduce Lakebase plugin --- .../server/lakebase-examples-plugin.ts | 12 +- .../lakebase-examples/drizzle-example.ts | 4 +- .../lakebase-examples/raw-driver-example.ts | 4 +- .../lakebase-examples/sequelize-example.ts | 4 +- .../lakebase-examples/typeorm-example.ts | 6 +- docs/docs/api/appkit/Class.LakebasePlugin.md | 579 ++++++++++++++ docs/docs/api/appkit/Class.Plugin.md | 5 + docs/docs/api/appkit/Class.ServerPlugin.md | 725 ++++++++++++++++++ docs/docs/api/appkit/index.md | 2 + docs/docs/api/appkit/typedoc-sidebar.ts | 10 + docs/docs/plugins.md | 85 +- packages/appkit/src/index.ts | 4 +- packages/appkit/src/plugins/index.ts | 1 + packages/appkit/src/plugins/lakebase/index.ts | 3 + .../appkit/src/plugins/lakebase/lakebase.ts | 131 ++++ .../appkit/src/plugins/lakebase/manifest.json | 10 + .../appkit/src/plugins/lakebase/manifest.ts | 10 + packages/appkit/src/plugins/lakebase/types.ts | 20 + packages/appkit/tsdown.config.ts | 4 + 19 files changed, 1599 insertions(+), 20 deletions(-) create mode 100644 docs/docs/api/appkit/Class.LakebasePlugin.md create mode 100644 docs/docs/api/appkit/Class.ServerPlugin.md create mode 100644 packages/appkit/src/plugins/lakebase/index.ts create mode 100644 packages/appkit/src/plugins/lakebase/lakebase.ts create mode 100644 packages/appkit/src/plugins/lakebase/manifest.json create mode 100644 packages/appkit/src/plugins/lakebase/manifest.ts create mode 100644 packages/appkit/src/plugins/lakebase/types.ts diff --git a/apps/dev-playground/server/lakebase-examples-plugin.ts b/apps/dev-playground/server/lakebase-examples-plugin.ts index 556b53c4..930653f8 100644 --- a/apps/dev-playground/server/lakebase-examples-plugin.ts +++ b/apps/dev-playground/server/lakebase-examples-plugin.ts @@ -1,4 +1,4 @@ -import { Plugin, toPlugin } from "@databricks/appkit"; +import { getUsernameWithApiLookup, Plugin, toPlugin } from "@databricks/appkit"; import type { IAppRouter } from "shared"; import * as drizzleExample from "./lakebase-examples/drizzle-example"; import * as rawExample from "./lakebase-examples/raw-driver-example"; @@ -42,12 +42,14 @@ export class LakebaseExamplesPlugin extends Plugin { } try { + const user = await getUsernameWithApiLookup(); + // Initialize all four examples in parallel await Promise.all([ - rawExample.setup(), - drizzleExample.setup(), - typeormExample.setup(), - sequelizeExample.setup(), + rawExample.setup(user), + drizzleExample.setup(user), + typeormExample.setup(user), + sequelizeExample.setup(user), ]); } catch (error) { console.error("Failed to initialize Lakebase examples:", error); diff --git a/apps/dev-playground/server/lakebase-examples/drizzle-example.ts b/apps/dev-playground/server/lakebase-examples/drizzle-example.ts index f0aa6c30..d4ede2ed 100644 --- a/apps/dev-playground/server/lakebase-examples/drizzle-example.ts +++ b/apps/dev-playground/server/lakebase-examples/drizzle-example.ts @@ -45,8 +45,8 @@ type NewActivityLog = typeof activityLogs.$inferInsert; let db: ReturnType; let pool: Pool; -export async function setup() { - pool = createLakebasePool(); +export async function setup(user?: string) { + pool = createLakebasePool({ user }); db = drizzle(pool); // For production apps, use: npx drizzle-kit push or drizzle-kit generate + migrate diff --git a/apps/dev-playground/server/lakebase-examples/raw-driver-example.ts b/apps/dev-playground/server/lakebase-examples/raw-driver-example.ts index 66d2ecb7..43b2ca3b 100644 --- a/apps/dev-playground/server/lakebase-examples/raw-driver-example.ts +++ b/apps/dev-playground/server/lakebase-examples/raw-driver-example.ts @@ -25,9 +25,9 @@ interface Product { created_at: Date; } -export async function setup() { +export async function setup(user?: string) { // Create pool with automatic OAuth token refresh - pool = createLakebasePool(); + pool = createLakebasePool({ user }); // Create schema and table (idempotent) await pool.query(` diff --git a/apps/dev-playground/server/lakebase-examples/sequelize-example.ts b/apps/dev-playground/server/lakebase-examples/sequelize-example.ts index f9f5b513..8792c99c 100644 --- a/apps/dev-playground/server/lakebase-examples/sequelize-example.ts +++ b/apps/dev-playground/server/lakebase-examples/sequelize-example.ts @@ -43,11 +43,11 @@ class Order let sequelize: Sequelize; -export async function setup() { +export async function setup(user?: string) { // @ts-expect-error password property supports a function for Lakehouse OAuth tokens sequelize = new Sequelize({ dialect: "postgres", - ...getLakebaseOrmConfig(), + ...getLakebaseOrmConfig({ user }), logging: false, }); diff --git a/apps/dev-playground/server/lakebase-examples/typeorm-example.ts b/apps/dev-playground/server/lakebase-examples/typeorm-example.ts index 171da14e..21b10831 100644 --- a/apps/dev-playground/server/lakebase-examples/typeorm-example.ts +++ b/apps/dev-playground/server/lakebase-examples/typeorm-example.ts @@ -43,16 +43,16 @@ class Task { let dataSource: DataSource; -export async function setup() { +export async function setup(user?: string) { // Create schema if not exists (TypeORM's synchronize doesn't create schemas) // See https://github.com/typeorm/typeorm/issues/3192 - const pool = createLakebasePool(); + const pool = createLakebasePool({ user }); await pool.query("CREATE SCHEMA IF NOT EXISTS typeorm_example"); await pool.end(); dataSource = new DataSource({ type: "postgres", - ...getLakebaseOrmConfig(), + ...getLakebaseOrmConfig({ user }), entities: [Task], synchronize: true, logging: false, diff --git a/docs/docs/api/appkit/Class.LakebasePlugin.md b/docs/docs/api/appkit/Class.LakebasePlugin.md new file mode 100644 index 00000000..4a03621e --- /dev/null +++ b/docs/docs/api/appkit/Class.LakebasePlugin.md @@ -0,0 +1,579 @@ +# Class: LakebasePlugin + +AppKit plugin for Databricks Lakebase Autoscaling. + +Wraps `@databricks/lakebase` to provide a standard `pg.Pool` with automatic +OAuth token refresh, integrated with AppKit's logger and OpenTelemetry setup. + +## Example + +```ts +import { createApp, lakebase, server } from "@databricks/appkit"; + +const AppKit = await createApp({ + plugins: [server(), lakebase()], +}); + +const result = await AppKit.lakebase.query("SELECT * FROM users WHERE id = $1", [userId]); +``` + +## Extends + +- [`Plugin`](Class.Plugin.md) + +## Constructors + +### Constructor + +```ts +new LakebasePlugin(config: ILakebaseConfig): LakebasePlugin; +``` + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `config` | `ILakebaseConfig` | + +#### Returns + +`LakebasePlugin` + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`constructor`](Class.Plugin.md#constructor) + +## Properties + +### app + +```ts +protected app: AppManager; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`app`](Class.Plugin.md#app) + +*** + +### cache + +```ts +protected cache: CacheManager; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`cache`](Class.Plugin.md#cache) + +*** + +### config + +```ts +protected config: ILakebaseConfig; +``` + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`config`](Class.Plugin.md#config) + +*** + +### devFileReader + +```ts +protected devFileReader: DevFileReader; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`devFileReader`](Class.Plugin.md#devfilereader) + +*** + +### isReady + +```ts +protected isReady: boolean = false; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`isReady`](Class.Plugin.md#isready) + +*** + +### name + +```ts +name: string = "lakebase"; +``` + +Plugin name identifier. + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`name`](Class.Plugin.md#name) + +*** + +### streamManager + +```ts +protected streamManager: StreamManager; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`streamManager`](Class.Plugin.md#streammanager) + +*** + +### telemetry + +```ts +protected telemetry: ITelemetry; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`telemetry`](Class.Plugin.md#telemetry) + +*** + +### manifest + +```ts +static manifest: PluginManifest = lakebaseManifest; +``` + +Plugin manifest declaring metadata and resource requirements + +*** + +### phase + +```ts +static phase: PluginPhase = "normal"; +``` + +Plugin initialization phase. +- 'core': Initialized first (e.g., config plugins) +- 'normal': Initialized second (most plugins) +- 'deferred': Initialized last (e.g., server plugin) + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`phase`](Class.Plugin.md#phase) + +## Methods + +### abortActiveOperations() + +```ts +abortActiveOperations(): void; +``` + +Gracefully drains and closes the connection pool. +Called automatically by AppKit during shutdown. + +#### Returns + +`void` + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`abortActiveOperations`](Class.Plugin.md#abortactiveoperations) + +*** + +### asUser() + +```ts +asUser(req: Request): this; +``` + +Execute operations using the user's identity from the request. +Returns a proxy of this plugin where all method calls execute +with the user's Databricks credentials instead of the service principal. + +#### Parameters + +| Parameter | Type | Description | +| ------ | ------ | ------ | +| `req` | `Request` | The Express request containing the user token in headers | + +#### Returns + +`this` + +A proxied plugin instance that executes as the user + +#### Throws + +Error if user token is not available in request headers + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`asUser`](Class.Plugin.md#asuser) + +*** + +### execute() + +```ts +protected execute( + fn: (signal?: AbortSignal) => Promise, + options: PluginExecutionSettings, +userKey?: string): Promise; +``` + +#### Type Parameters + +| Type Parameter | +| ------ | +| `T` | + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `fn` | (`signal?`: `AbortSignal`) => `Promise`\<`T`\> | +| `options` | `PluginExecutionSettings` | +| `userKey?` | `string` | + +#### Returns + +`Promise`\<`T` \| `undefined`\> + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`execute`](Class.Plugin.md#execute) + +*** + +### executeStream() + +```ts +protected executeStream( + res: IAppResponse, + fn: StreamExecuteHandler, + options: StreamExecutionSettings, +userKey?: string): Promise; +``` + +#### Type Parameters + +| Type Parameter | +| ------ | +| `T` | + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `res` | `IAppResponse` | +| `fn` | `StreamExecuteHandler`\<`T`\> | +| `options` | [`StreamExecutionSettings`](Interface.StreamExecutionSettings.md) | +| `userKey?` | `string` | + +#### Returns + +`Promise`\<`void`\> + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`executeStream`](Class.Plugin.md#executestream) + +*** + +### exports() + +```ts +exports(): { + getOrmConfig: () => { + password: string | () => string | () => Promise | undefined; + ssl: | boolean + | { + rejectUnauthorized: boolean | undefined; + }; + username: string | undefined; + }; + getPgConfig: () => PoolConfig; + pool: Pool; + query: (text: string, values?: unknown[]) => Promise>; +}; +``` + +Returns the plugin's public API, accessible via `AppKit.lakebase`. + +- `pool` — The raw `pg.Pool` instance, for use with ORMs or advanced scenarios +- `query` — Convenience method for executing parameterized SQL queries +- `getOrmConfig()` — Returns a config object compatible with Drizzle, TypeORM, Sequelize, etc. +- `getPgConfig()` — Returns a `pg.PoolConfig` object for manual pool construction + +#### Returns + +##### getOrmConfig() + +```ts +getOrmConfig: () => { + password: string | () => string | () => Promise | undefined; + ssl: | boolean + | { + rejectUnauthorized: boolean | undefined; + }; + username: string | undefined; +}; +``` + +###### Returns + +```ts +{ + password: string | () => string | () => Promise | undefined; + ssl: | boolean + | { + rejectUnauthorized: boolean | undefined; + }; + username: string | undefined; +} +``` + +###### password + +```ts +password: string | () => string | () => Promise | undefined; +``` + +###### ssl + +```ts +ssl: + | boolean + | { + rejectUnauthorized: boolean | undefined; +}; +``` + +###### username + +```ts +username: string | undefined = user; +``` + +##### getPgConfig() + +```ts +getPgConfig: () => PoolConfig; +``` + +###### Returns + +`PoolConfig` + +##### pool + +```ts +pool: Pool; +``` + +##### query() + +```ts +query: (text: string, values?: unknown[]) => Promise>; +``` + +Executes a parameterized SQL query against the Lakebase pool. + +###### Type Parameters + +| Type Parameter | Default type | +| ------ | ------ | +| `T` *extends* `QueryResultRow` | `any` | + +###### Parameters + +| Parameter | Type | Description | +| ------ | ------ | ------ | +| `text` | `string` | SQL query string, using `$1`, `$2`, ... placeholders | +| `values?` | `unknown`[] | Parameter values corresponding to placeholders | + +###### Returns + +`Promise`\<`QueryResult`\<`T`\>\> + +Query result with typed rows + +###### Throws + +If the pool has not been initialized (i.e. `setup()` was not called) + +###### Example + +```ts +const result = await AppKit.lakebase.query<{ id: number; name: string }>( + "SELECT id, name FROM users WHERE active = $1", + [true], +); +``` + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`exports`](Class.Plugin.md#exports) + +*** + +### getEndpoints() + +```ts +getEndpoints(): PluginEndpointMap; +``` + +#### Returns + +`PluginEndpointMap` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`getEndpoints`](Class.Plugin.md#getendpoints) + +*** + +### injectRoutes() + +```ts +injectRoutes(_: Router): void; +``` + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `_` | `Router` | + +#### Returns + +`void` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`injectRoutes`](Class.Plugin.md#injectroutes) + +*** + +### query() + +```ts +query(text: string, values?: unknown[]): Promise>; +``` + +Executes a parameterized SQL query against the Lakebase pool. + +#### Type Parameters + +| Type Parameter | Default type | +| ------ | ------ | +| `T` *extends* `QueryResultRow` | `any` | + +#### Parameters + +| Parameter | Type | Description | +| ------ | ------ | ------ | +| `text` | `string` | SQL query string, using `$1`, `$2`, ... placeholders | +| `values?` | `unknown`[] | Parameter values corresponding to placeholders | + +#### Returns + +`Promise`\<`QueryResult`\<`T`\>\> + +Query result with typed rows + +#### Throws + +If the pool has not been initialized (i.e. `setup()` was not called) + +#### Example + +```ts +const result = await AppKit.lakebase.query<{ id: number; name: string }>( + "SELECT id, name FROM users WHERE active = $1", + [true], +); +``` + +*** + +### registerEndpoint() + +```ts +protected registerEndpoint(name: string, path: string): void; +``` + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `name` | `string` | +| `path` | `string` | + +#### Returns + +`void` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`registerEndpoint`](Class.Plugin.md#registerendpoint) + +*** + +### route() + +```ts +protected route<_TResponse>(router: Router, config: RouteConfig): void; +``` + +#### Type Parameters + +| Type Parameter | +| ------ | +| `_TResponse` | + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `router` | `Router` | +| `config` | `RouteConfig` | + +#### Returns + +`void` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`route`](Class.Plugin.md#route) + +*** + +### setup() + +```ts +setup(): Promise; +``` + +Initializes the Lakebase connection pool. +Called automatically by AppKit during the plugin setup phase. + +Resolves the PostgreSQL username via [getUsernameWithApiLookup](Function.getUsernameWithApiLookup.md), +which tries config, env vars, and finally the Databricks workspace API. + +#### Returns + +`Promise`\<`void`\> + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`setup`](Class.Plugin.md#setup) diff --git a/docs/docs/api/appkit/Class.Plugin.md b/docs/docs/api/appkit/Class.Plugin.md index 64de5830..4c1f0403 100644 --- a/docs/docs/api/appkit/Class.Plugin.md +++ b/docs/docs/api/appkit/Class.Plugin.md @@ -84,6 +84,11 @@ class MyPlugin extends Plugin { } ``` +## Extended by + +- [`LakebasePlugin`](Class.LakebasePlugin.md) +- [`ServerPlugin`](Class.ServerPlugin.md) + ## Type Parameters | Type Parameter | Default type | diff --git a/docs/docs/api/appkit/Class.ServerPlugin.md b/docs/docs/api/appkit/Class.ServerPlugin.md new file mode 100644 index 00000000..4058343d --- /dev/null +++ b/docs/docs/api/appkit/Class.ServerPlugin.md @@ -0,0 +1,725 @@ +# Class: ServerPlugin + +Server plugin for the AppKit. + +This plugin is responsible for starting the server and serving the static files. +It also handles the remote tunneling for development purposes. + +## Example + +```ts +createApp({ + plugins: [server(), telemetryExamples(), analytics({})], +}); +``` + +## Extends + +- [`Plugin`](Class.Plugin.md) + +## Constructors + +### Constructor + +```ts +new ServerPlugin(config: ServerConfig): ServerPlugin; +``` + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `config` | `ServerConfig` | + +#### Returns + +`ServerPlugin` + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`constructor`](Class.Plugin.md#constructor) + +## Properties + +### app + +```ts +protected app: AppManager; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`app`](Class.Plugin.md#app) + +*** + +### cache + +```ts +protected cache: CacheManager; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`cache`](Class.Plugin.md#cache) + +*** + +### config + +```ts +protected config: ServerConfig; +``` + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`config`](Class.Plugin.md#config) + +*** + +### devFileReader + +```ts +protected devFileReader: DevFileReader; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`devFileReader`](Class.Plugin.md#devfilereader) + +*** + +### isReady + +```ts +protected isReady: boolean = false; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`isReady`](Class.Plugin.md#isready) + +*** + +### name + +```ts +name: "server"; +``` + +Plugin name identifier. + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`name`](Class.Plugin.md#name) + +*** + +### streamManager + +```ts +protected streamManager: StreamManager; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`streamManager`](Class.Plugin.md#streammanager) + +*** + +### telemetry + +```ts +protected telemetry: ITelemetry; +``` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`telemetry`](Class.Plugin.md#telemetry) + +*** + +### DEFAULT\_CONFIG + +```ts +static DEFAULT_CONFIG: { + autoStart: boolean; + host: string; + port: number; +}; +``` + +#### autoStart + +```ts +autoStart: boolean = true; +``` + +#### host + +```ts +host: string; +``` + +#### port + +```ts +port: number; +``` + +*** + +### manifest + +```ts +static manifest: PluginManifest = serverManifest; +``` + +Plugin manifest declaring metadata and resource requirements + +*** + +### phase + +```ts +static phase: PluginPhase = "deferred"; +``` + +Plugin initialization phase. +- 'core': Initialized first (e.g., config plugins) +- 'normal': Initialized second (most plugins) +- 'deferred': Initialized last (e.g., server plugin) + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`phase`](Class.Plugin.md#phase) + +## Methods + +### abortActiveOperations() + +```ts +abortActiveOperations(): void; +``` + +#### Returns + +`void` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`abortActiveOperations`](Class.Plugin.md#abortactiveoperations) + +*** + +### asUser() + +```ts +asUser(req: Request): this; +``` + +Execute operations using the user's identity from the request. +Returns a proxy of this plugin where all method calls execute +with the user's Databricks credentials instead of the service principal. + +#### Parameters + +| Parameter | Type | Description | +| ------ | ------ | ------ | +| `req` | `Request` | The Express request containing the user token in headers | + +#### Returns + +`this` + +A proxied plugin instance that executes as the user + +#### Throws + +Error if user token is not available in request headers + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`asUser`](Class.Plugin.md#asuser) + +*** + +### execute() + +```ts +protected execute( + fn: (signal?: AbortSignal) => Promise, + options: PluginExecutionSettings, +userKey?: string): Promise; +``` + +#### Type Parameters + +| Type Parameter | +| ------ | +| `T` | + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `fn` | (`signal?`: `AbortSignal`) => `Promise`\<`T`\> | +| `options` | `PluginExecutionSettings` | +| `userKey?` | `string` | + +#### Returns + +`Promise`\<`T` \| `undefined`\> + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`execute`](Class.Plugin.md#execute) + +*** + +### executeStream() + +```ts +protected executeStream( + res: IAppResponse, + fn: StreamExecuteHandler, + options: StreamExecutionSettings, +userKey?: string): Promise; +``` + +#### Type Parameters + +| Type Parameter | +| ------ | +| `T` | + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `res` | `IAppResponse` | +| `fn` | `StreamExecuteHandler`\<`T`\> | +| `options` | [`StreamExecutionSettings`](Interface.StreamExecutionSettings.md) | +| `userKey?` | `string` | + +#### Returns + +`Promise`\<`void`\> + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`executeStream`](Class.Plugin.md#executestream) + +*** + +### exports() + +```ts +exports(): { + getConfig: () => { + [key: string]: unknown; + autoStart?: boolean; + host?: string; + name?: string; + port?: number; + staticPath?: string; + telemetry?: TelemetryOptions; + }; + getServer: () => Server; + start: () => Promise; + extend: { start: () => Promise; extend(fn: (app: Application) => void): ...; getServer: () => Server; getConfig: () => { ...; }; }; +}; +``` + +Returns the public exports for the server plugin. +Exposes server management methods. + +#### Returns + +##### getConfig() + +```ts +getConfig: () => { +[key: string]: unknown; + autoStart?: boolean; + host?: string; + name?: string; + port?: number; + staticPath?: string; + telemetry?: TelemetryOptions; +}; +``` + +Get the server configuration + +Get the server configuration. + +###### Returns + +```ts +{ +[key: string]: unknown; + autoStart?: boolean; + host?: string; + name?: string; + port?: number; + staticPath?: string; + telemetry?: TelemetryOptions; +} +``` + +###### autoStart? + +```ts +optional autoStart: boolean; +``` + +###### host? + +```ts +optional host: string; +``` + +###### name? + +```ts +optional name: string; +``` + +###### port? + +```ts +optional port: number; +``` + +###### staticPath? + +```ts +optional staticPath: string; +``` + +###### telemetry? + +```ts +optional telemetry: TelemetryOptions; +``` + +##### getServer() + +```ts +getServer: () => Server; +``` + +Get the underlying HTTP server instance + +Get the low level node.js http server instance. + +Only use this method if you need to access the server instance for advanced usage like a custom websocket server, etc. + +###### Returns + +`Server` + +The server instance. + +###### Throws + +If the server is not started or autoStart is true. + +##### start() + +```ts +start: () => Promise; +``` + +Start the server + +Start the server. + +This method starts the server and sets up the frontend. +It also sets up the remote tunneling if enabled. + +###### Returns + +`Promise`\<`Application`\> + +The express application. + +##### extend() + +```ts +extend(fn: (app: Application) => void): { start: () => Promise; extend(fn: (app: Application) => void): ...; getServer: () => Server; getConfig: () => { ...; }; }; +``` + +Extend the server with custom routes or middleware + +###### Parameters + +| Parameter | Type | +| ------ | ------ | +| `fn` | (`app`: `Application`) => `void` | + +###### Returns + +\{ start: () =\> Promise\; extend(fn: (app: Application) =\> void): ...; getServer: () =\> Server\; getConfig: () =\> \{ ...; \}; \} + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`exports`](Class.Plugin.md#exports) + +*** + +### extend() + +```ts +extend(fn: (app: Application) => void): ServerPlugin; +``` + +Extend the server with custom routes or middleware. + +#### Parameters + +| Parameter | Type | Description | +| ------ | ------ | ------ | +| `fn` | (`app`: `Application`) => `void` | A function that receives the express application. | + +#### Returns + +`ServerPlugin` + +The server plugin instance for chaining. + +#### Throws + +If autoStart is true. + +*** + +### getConfig() + +```ts +getConfig(): { +[key: string]: unknown; + autoStart?: boolean; + host?: string; + name?: string; + port?: number; + staticPath?: string; + telemetry?: TelemetryOptions; +}; +``` + +Get the server configuration. + +#### Returns + +```ts +{ +[key: string]: unknown; + autoStart?: boolean; + host?: string; + name?: string; + port?: number; + staticPath?: string; + telemetry?: TelemetryOptions; +} +``` + +##### autoStart? + +```ts +optional autoStart: boolean; +``` + +##### host? + +```ts +optional host: string; +``` + +##### name? + +```ts +optional name: string; +``` + +##### port? + +```ts +optional port: number; +``` + +##### staticPath? + +```ts +optional staticPath: string; +``` + +##### telemetry? + +```ts +optional telemetry: TelemetryOptions; +``` + +*** + +### getEndpoints() + +```ts +getEndpoints(): PluginEndpointMap; +``` + +#### Returns + +`PluginEndpointMap` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`getEndpoints`](Class.Plugin.md#getendpoints) + +*** + +### getServer() + +```ts +getServer(): Server; +``` + +Get the low level node.js http server instance. + +Only use this method if you need to access the server instance for advanced usage like a custom websocket server, etc. + +#### Returns + +`Server` + +The server instance. + +#### Throws + +If the server is not started or autoStart is true. + +*** + +### injectRoutes() + +```ts +injectRoutes(_: Router): void; +``` + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `_` | `Router` | + +#### Returns + +`void` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`injectRoutes`](Class.Plugin.md#injectroutes) + +*** + +### registerEndpoint() + +```ts +protected registerEndpoint(name: string, path: string): void; +``` + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `name` | `string` | +| `path` | `string` | + +#### Returns + +`void` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`registerEndpoint`](Class.Plugin.md#registerendpoint) + +*** + +### route() + +```ts +protected route<_TResponse>(router: Router, config: RouteConfig): void; +``` + +#### Type Parameters + +| Type Parameter | +| ------ | +| `_TResponse` | + +#### Parameters + +| Parameter | Type | +| ------ | ------ | +| `router` | `Router` | +| `config` | `RouteConfig` | + +#### Returns + +`void` + +#### Inherited from + +[`Plugin`](Class.Plugin.md).[`route`](Class.Plugin.md#route) + +*** + +### setup() + +```ts +setup(): Promise; +``` + +Setup the server plugin. + +#### Returns + +`Promise`\<`void`\> + +#### Overrides + +[`Plugin`](Class.Plugin.md).[`setup`](Class.Plugin.md#setup) + +*** + +### shouldAutoStart() + +```ts +shouldAutoStart(): boolean | undefined; +``` + +Check if the server should auto start. + +#### Returns + +`boolean` \| `undefined` + +*** + +### start() + +```ts +start(): Promise; +``` + +Start the server. + +This method starts the server and sets up the frontend. +It also sets up the remote tunneling if enabled. + +#### Returns + +`Promise`\<`Application`\> + +The express application. diff --git a/docs/docs/api/appkit/index.md b/docs/docs/api/appkit/index.md index 2bd9ad71..98d18ea4 100644 --- a/docs/docs/api/appkit/index.md +++ b/docs/docs/api/appkit/index.md @@ -20,9 +20,11 @@ plugin architecture, and React integration. | [ConnectionError](Class.ConnectionError.md) | Error thrown when a connection or network operation fails. Use for database pool errors, API failures, timeouts, etc. | | [ExecutionError](Class.ExecutionError.md) | Error thrown when an operation execution fails. Use for statement failures, canceled operations, or unexpected states. | | [InitializationError](Class.InitializationError.md) | Error thrown when a service or component is not properly initialized. Use when accessing services before they are ready. | +| [LakebasePlugin](Class.LakebasePlugin.md) | AppKit plugin for Databricks Lakebase Autoscaling. | | [Plugin](Class.Plugin.md) | Base abstract class for creating AppKit plugins. | | [ResourceRegistry](Class.ResourceRegistry.md) | Central registry for tracking plugin resource requirements. Deduplication uses type + resourceKey (machine-stable); alias is for display only. | | [ServerError](Class.ServerError.md) | Error thrown when server lifecycle operations fail. Use for server start/stop issues, configuration conflicts, etc. | +| [ServerPlugin](Class.ServerPlugin.md) | Server plugin for the AppKit. | | [TunnelError](Class.TunnelError.md) | Error thrown when remote tunnel operations fail. Use for tunnel connection issues, message parsing failures, etc. | | [ValidationError](Class.ValidationError.md) | Error thrown when input validation fails. Use for invalid parameters, missing required fields, or type mismatches. | diff --git a/docs/docs/api/appkit/typedoc-sidebar.ts b/docs/docs/api/appkit/typedoc-sidebar.ts index 21df87aa..5329fd1b 100644 --- a/docs/docs/api/appkit/typedoc-sidebar.ts +++ b/docs/docs/api/appkit/typedoc-sidebar.ts @@ -51,6 +51,11 @@ const typedocSidebar: SidebarsConfig = { id: "api/appkit/Class.InitializationError", label: "InitializationError" }, + { + type: "doc", + id: "api/appkit/Class.LakebasePlugin", + label: "LakebasePlugin" + }, { type: "doc", id: "api/appkit/Class.Plugin", @@ -66,6 +71,11 @@ const typedocSidebar: SidebarsConfig = { id: "api/appkit/Class.ServerError", label: "ServerError" }, + { + type: "doc", + id: "api/appkit/Class.ServerPlugin", + label: "ServerPlugin" + }, { type: "doc", id: "api/appkit/Class.TunnelError", diff --git a/docs/docs/plugins.md b/docs/docs/plugins.md index 80ea8b0e..26178e31 100644 --- a/docs/docs/plugins.md +++ b/docs/docs/plugins.md @@ -143,19 +143,94 @@ The analytics plugin exposes these endpoints (mounted under `/api/analytics`): - `format: "JSON"` (default) returns JSON rows - `format: "ARROW"` returns an Arrow "statement_id" payload over SSE, then the client fetches binary Arrow from `/api/analytics/arrow-result/:jobId` -### Execution context and `asUser(req)` +### Lakebase plugin + +Provides a PostgreSQL connection pool for Databricks Lakebase Autoscaling with automatic OAuth token refresh. + +**Key features:** +- Standard `pg.Pool` compatible with any PostgreSQL library or ORM +- Automatic OAuth token refresh (1-hour tokens, 2-minute refresh buffer) +- Token caching to minimize API calls +- Built-in OpenTelemetry instrumentation (query duration, pool connections, token refresh) + +#### Basic usage + +```ts +import { createApp, lakebase, server } from "@databricks/appkit"; + +await createApp({ + plugins: [server(), lakebase()], +}); +``` + +#### Environment variables + +The three required environment variables: + +| Variable | Description | +|---|---| +| `PGHOST` | Lakebase host | +| `PGDATABASE` | Database name | +| `LAKEBASE_ENDPOINT` | Endpoint resource path (e.g. `projects/.../branches/.../endpoints/...`) | + +Ensure that those environment variables are set both for local development (`.env` file) and for deployment (`app.yaml` file). + +For the full configuration reference (SSL, pool size, timeouts, logging, ORM examples), see the [`@databricks/lakebase` README](https://github.com/databricks/appkit/blob/main/packages/lakebase/README.md). + +#### Accessing the pool + +After initialization, access Lakebase through the `AppKit.lakebase` object: + +```ts +const AppKit = await createApp({ + plugins: [server(), lakebase()], +}); + +// Direct query (parameterized) +const result = await AppKit.lakebase.query( + "SELECT * FROM orders WHERE user_id = $1", + [userId], +); + +// Raw pg.Pool (for ORMs or advanced usage) +const pool = AppKit.lakebase.pool; + +// ORM-ready config objects +const ormConfig = AppKit.lakebase.getOrmConfig(); // { host, port, database, ... } +const pgConfig = AppKit.lakebase.getPgConfig(); // pg.PoolConfig +``` + +#### Configuration options + +Pass a `pool` object to override any defaults: + +```ts +await createApp({ + plugins: [ + lakebase({ + pool: { + max: 10, // Max pool connections (default: 10) + connectionTimeoutMillis: 5000, // Connection timeout ms (default: 10000) + idleTimeoutMillis: 30000, // Idle connection timeout ms (default: 30000) + }, + }), + ], +}); +``` + +## Execution context and `asUser(req)` AppKit manages Databricks authentication via two contexts: - **ServiceContext** (singleton): Initialized at app startup with service principal credentials - **ExecutionContext**: Determined at runtime - either service principal or user context -#### Headers for user context +### Headers for user context - `x-forwarded-user`: required in production; identifies the user - `x-forwarded-access-token`: required for user token passthrough -#### Using `asUser(req)` for user-scoped operations +### Using `asUser(req)` for user-scoped operations The `asUser(req)` pattern allows plugins to execute operations using the requesting user's credentials: @@ -174,7 +249,7 @@ router.post("/system/data", async (req, res) => { }); ``` -#### Context helper functions +### Context helper functions Exported from `@databricks/appkit`: @@ -184,7 +259,7 @@ Exported from `@databricks/appkit`: - `getWorkspaceId()`: `Promise` (from `DATABRICKS_WORKSPACE_ID` or fetched) - `isInUserContext()`: Returns `true` if currently executing in user context -#### Development mode behavior +### Development mode behavior In local development (`NODE_ENV=development`), if `asUser(req)` is called without a user token, it logs a warning and falls back to the service principal. diff --git a/packages/appkit/src/index.ts b/packages/appkit/src/index.ts index 45cad458..9732c0d0 100644 --- a/packages/appkit/src/index.ts +++ b/packages/appkit/src/index.ts @@ -47,7 +47,9 @@ export { } from "./errors"; // Plugin authoring export { Plugin, type ToPlugin, toPlugin } from "./plugin"; -export { analytics, server } from "./plugins"; +export { analytics, lakebase, server } from "./plugins"; +export { LakebasePlugin } from "./plugins/lakebase"; +export { ServerPlugin } from "./plugins/server"; // Registry types and utilities for plugin manifests export type { ConfigSchema, diff --git a/packages/appkit/src/plugins/index.ts b/packages/appkit/src/plugins/index.ts index aba6f26b..f6a9e2c5 100644 --- a/packages/appkit/src/plugins/index.ts +++ b/packages/appkit/src/plugins/index.ts @@ -1,2 +1,3 @@ export * from "./analytics"; +export * from "./lakebase"; export * from "./server"; diff --git a/packages/appkit/src/plugins/lakebase/index.ts b/packages/appkit/src/plugins/lakebase/index.ts new file mode 100644 index 00000000..73bcff5e --- /dev/null +++ b/packages/appkit/src/plugins/lakebase/index.ts @@ -0,0 +1,3 @@ +export * from "./lakebase"; +export * from "./manifest"; +export * from "./types"; diff --git a/packages/appkit/src/plugins/lakebase/lakebase.ts b/packages/appkit/src/plugins/lakebase/lakebase.ts new file mode 100644 index 00000000..a72ef4f6 --- /dev/null +++ b/packages/appkit/src/plugins/lakebase/lakebase.ts @@ -0,0 +1,131 @@ +import type pg from "pg"; +import { + createLakebasePool, + getLakebaseOrmConfig, + getLakebasePgConfig, + getUsernameWithApiLookup, +} from "../../connectors/lakebase"; +import { createLogger } from "../../logging/logger"; +import { Plugin, toPlugin } from "../../plugin"; +import { lakebaseManifest } from "./manifest"; +import type { ILakebaseConfig } from "./types"; + +const logger = createLogger("lakebase"); + +/** + * AppKit plugin for Databricks Lakebase Autoscaling. + * + * Wraps `@databricks/lakebase` to provide a standard `pg.Pool` with automatic + * OAuth token refresh, integrated with AppKit's logger and OpenTelemetry setup. + * + * @example + * ```ts + * import { createApp, lakebase, server } from "@databricks/appkit"; + * + * const AppKit = await createApp({ + * plugins: [server(), lakebase()], + * }); + * + * const result = await AppKit.lakebase.query("SELECT * FROM users WHERE id = $1", [userId]); + * ``` + */ +export class LakebasePlugin extends Plugin { + name = "lakebase"; + + /** Plugin manifest declaring metadata and resource requirements */ + static manifest = lakebaseManifest; + + protected declare config: ILakebaseConfig; + private pool: pg.Pool | null = null; + + constructor(config: ILakebaseConfig) { + super(config); + this.config = config; + } + + /** + * Initializes the Lakebase connection pool. + * Called automatically by AppKit during the plugin setup phase. + * + * Resolves the PostgreSQL username via {@link getUsernameWithApiLookup}, + * which tries config, env vars, and finally the Databricks workspace API. + */ + async setup() { + const poolConfig = this.config.pool; + const user = await getUsernameWithApiLookup(poolConfig); + this.pool = createLakebasePool({ ...poolConfig, user }); + logger.info("Lakebase pool initialized"); + } + + /** + * Executes a parameterized SQL query against the Lakebase pool. + * + * @param text - SQL query string, using `$1`, `$2`, ... placeholders + * @param values - Parameter values corresponding to placeholders + * @returns Query result with typed rows + * @throws If the pool has not been initialized (i.e. `setup()` was not called) + * + * @example + * ```ts + * const result = await AppKit.lakebase.query<{ id: number; name: string }>( + * "SELECT id, name FROM users WHERE active = $1", + * [true], + * ); + * ``` + */ + async query( + text: string, + values?: unknown[], + ): Promise> { + if (!this.pool) { + throw new Error("Lakebase pool not initialized. Was setup() called?"); + } + return this.pool.query(text, values); + } + + /** + * Gracefully drains and closes the connection pool. + * Called automatically by AppKit during shutdown. + */ + abortActiveOperations(): void { + super.abortActiveOperations(); + if (this.pool) { + logger.info("Closing Lakebase pool"); + this.pool.end().catch((err) => { + logger.error("Error closing Lakebase pool: %O", err); + }); + this.pool = null; + } + } + + /** + * Returns the plugin's public API, accessible via `AppKit.lakebase`. + * + * - `pool` — The raw `pg.Pool` instance, for use with ORMs or advanced scenarios + * - `query` — Convenience method for executing parameterized SQL queries + * - `getOrmConfig()` — Returns a config object compatible with Drizzle, TypeORM, Sequelize, etc. + * - `getPgConfig()` — Returns a `pg.PoolConfig` object for manual pool construction + */ + exports() { + const pool = this.pool; + if (!pool) { + throw new Error("Lakebase pool not initialized. Was setup() called?"); + } + + return { + pool: pool, + query: this.query.bind(this), + getOrmConfig: () => getLakebaseOrmConfig(this.config.pool), + getPgConfig: () => getLakebasePgConfig(this.config.pool), + }; + } +} + +/** + * @internal + */ +export const lakebase = toPlugin< + typeof LakebasePlugin, + ILakebaseConfig, + "lakebase" +>(LakebasePlugin, "lakebase"); diff --git a/packages/appkit/src/plugins/lakebase/manifest.json b/packages/appkit/src/plugins/lakebase/manifest.json new file mode 100644 index 00000000..17415d5b --- /dev/null +++ b/packages/appkit/src/plugins/lakebase/manifest.json @@ -0,0 +1,10 @@ +{ + "$schema": "https://databricks.github.io/appkit/schemas/plugin-manifest.schema.json", + "name": "lakebase", + "displayName": "Lakebase", + "description": "SQL query execution against Databricks Lakebase Autoscaling", + "resources": { + "required": [], + "optional": [] + } +} diff --git a/packages/appkit/src/plugins/lakebase/manifest.ts b/packages/appkit/src/plugins/lakebase/manifest.ts new file mode 100644 index 00000000..7575062a --- /dev/null +++ b/packages/appkit/src/plugins/lakebase/manifest.ts @@ -0,0 +1,10 @@ +import { readFileSync } from "node:fs"; +import { dirname, join } from "node:path"; +import { fileURLToPath } from "node:url"; +import type { PluginManifest } from "../../registry"; + +const __dirname = dirname(fileURLToPath(import.meta.url)); + +export const lakebaseManifest: PluginManifest = JSON.parse( + readFileSync(join(__dirname, "manifest.json"), "utf-8"), +) as PluginManifest; diff --git a/packages/appkit/src/plugins/lakebase/types.ts b/packages/appkit/src/plugins/lakebase/types.ts new file mode 100644 index 00000000..ac6997c6 --- /dev/null +++ b/packages/appkit/src/plugins/lakebase/types.ts @@ -0,0 +1,20 @@ +import type { BasePluginConfig } from "shared"; +import type { LakebasePoolConfig } from "../../connectors/lakebase"; + +/** + * Configuration for the Lakebase plugin. + * + * The minimum required setup is via environment variables — no `pool` config + * is needed if `PGHOST`, `PGDATABASE`, and `LAKEBASE_ENDPOINT` are set. + * + * @see {@link https://github.com/databricks/appkit/blob/main/packages/lakebase/README.md} for the full configuration reference. + */ +export interface ILakebaseConfig extends BasePluginConfig { + /** + * Optional overrides for the underlying `pg.Pool` configuration. + * All fields are optional and fall back to environment variables or defaults. + * + * Common overrides: `max` (pool size), `connectionTimeoutMillis`, `idleTimeoutMillis`. + */ + pool?: Partial; +} diff --git a/packages/appkit/tsdown.config.ts b/packages/appkit/tsdown.config.ts index 2472c084..32600ee7 100644 --- a/packages/appkit/tsdown.config.ts +++ b/packages/appkit/tsdown.config.ts @@ -42,6 +42,10 @@ export default defineConfig([ from: "src/plugins/analytics/manifest.json", to: "dist/plugins/analytics/manifest.json", }, + { + from: "src/plugins/lakebase/manifest.json", + to: "dist/plugins/lakebase/manifest.json", + }, { from: "src/plugins/server/manifest.json", to: "dist/plugins/server/manifest.json", From 9074a172524c5e7ea98fda564b80bc13f7bb2cfa Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Mon, 23 Feb 2026 20:01:18 +0100 Subject: [PATCH 2/9] docs: describe how to connect an AppKit app with Lakebase --- docs/docs/architecture.md | 4 +- docs/docs/configuration.mdx | 2 +- docs/docs/development/project-setup.md | 2 +- docs/docs/development/type-generation.md | 2 +- docs/docs/plugins.md | 557 ------------------ docs/docs/plugins/_category_.json | 10 + docs/docs/plugins/analytics.md | 67 +++ .../plugins/assets/lakebase-setup/step-1.png | Bin 0 -> 43577 bytes .../plugins/assets/lakebase-setup/step-2.png | Bin 0 -> 61813 bytes .../plugins/assets/lakebase-setup/step-4.png | Bin 0 -> 48582 bytes .../plugins/assets/lakebase-setup/step-5.png | Bin 0 -> 108930 bytes .../plugins/assets/lakebase-setup/step-6.png | Bin 0 -> 42079 bytes docs/docs/plugins/caching.md | 35 ++ docs/docs/plugins/custom-plugins.md | 151 +++++ docs/docs/plugins/execution-context.md | 48 ++ docs/docs/plugins/index.md | 34 ++ docs/docs/plugins/lakebase.md | 171 ++++++ docs/docs/plugins/plugin-management.md | 85 +++ docs/docs/plugins/server.md | 72 +++ 19 files changed, 678 insertions(+), 562 deletions(-) delete mode 100644 docs/docs/plugins.md create mode 100644 docs/docs/plugins/_category_.json create mode 100644 docs/docs/plugins/analytics.md create mode 100644 docs/docs/plugins/assets/lakebase-setup/step-1.png create mode 100644 docs/docs/plugins/assets/lakebase-setup/step-2.png create mode 100644 docs/docs/plugins/assets/lakebase-setup/step-4.png create mode 100644 docs/docs/plugins/assets/lakebase-setup/step-5.png create mode 100644 docs/docs/plugins/assets/lakebase-setup/step-6.png create mode 100644 docs/docs/plugins/caching.md create mode 100644 docs/docs/plugins/custom-plugins.md create mode 100644 docs/docs/plugins/execution-context.md create mode 100644 docs/docs/plugins/index.md create mode 100644 docs/docs/plugins/lakebase.md create mode 100644 docs/docs/plugins/plugin-management.md create mode 100644 docs/docs/plugins/server.md diff --git a/docs/docs/architecture.md b/docs/docs/architecture.md index d9d26c4a..c878faec 100644 --- a/docs/docs/architecture.md +++ b/docs/docs/architecture.md @@ -47,7 +47,7 @@ The backend SDK that provides the plugin architecture and core functionality. It - Cache management and streaming capabilities - Type generation for SQL queries -See the [Plugins](./plugins.md) and [API reference](./api/appkit/) documentation for detailed information. +See the [Plugins](./plugins/index.md) and [API reference](./api/appkit/) documentation for detailed information. ### @databricks/appkit-ui @@ -87,7 +87,7 @@ Integration with Databricks services: ## See also -- [Plugins](./plugins.md): Deep dive into the plugin system +- [Plugins](./plugins/index.md): Deep dive into the plugin system - [API reference](./api/): Complete API documentation - [Development](./development/): Explore development workflows - [Core Principles](./core-principles.md): Learn about AppKit's design philosophy diff --git a/docs/docs/configuration.mdx b/docs/docs/configuration.mdx index c7ca9a32..22f0aff2 100644 --- a/docs/docs/configuration.mdx +++ b/docs/docs/configuration.mdx @@ -142,4 +142,4 @@ For advanced Databricks Apps configuration (authorization, networking, resource ## See also - [App management](./app-management.mdx) - Deploying and managing apps -- [Plugins](./plugins.md) - Plugin configuration options +- [Plugins](./plugins/index.md) - Plugin configuration options diff --git a/docs/docs/development/project-setup.md b/docs/docs/development/project-setup.md index 7f271ecb..b192abbe 100644 --- a/docs/docs/development/project-setup.md +++ b/docs/docs/development/project-setup.md @@ -232,4 +232,4 @@ Then create `config/queries/` and add your `.sql` files. - [Local development](./local-development.mdx) - Running the dev server - [Configuration](../configuration.mdx) - Environment variables -- [Plugins](../plugins.md) - Plugin configuration +- [Plugins](../plugins/index.md) - Plugin configuration diff --git a/docs/docs/development/type-generation.md b/docs/docs/development/type-generation.md index ef277f12..c6bc0f8d 100644 --- a/docs/docs/development/type-generation.md +++ b/docs/docs/development/type-generation.md @@ -104,5 +104,5 @@ data?.forEach(row => { ## See also -- [Plugins](../plugins.md) - Analytics plugin configuration +- [Plugins](../plugins/index.md) - Analytics plugin configuration - [API Reference](/docs/api/appkit-ui) - Complete UI components API documentation diff --git a/docs/docs/plugins.md b/docs/docs/plugins.md deleted file mode 100644 index 26178e31..00000000 --- a/docs/docs/plugins.md +++ /dev/null @@ -1,557 +0,0 @@ ---- -sidebar_position: 3 ---- - -# Plugins - -Plugins are modular extensions that add capabilities to your AppKit application. They follow a defined lifecycle and have access to shared services like caching, telemetry, and streaming. - -For complete API documentation, see the [`Plugin`](api/appkit/Class.Plugin.md) class reference. - -## Built-in plugins - -### Server plugin - -Provides HTTP server capabilities with development and production modes. - -**Key features:** -- Express server for REST APIs -- Vite dev server with hot module reload -- Static file serving for production -- Remote tunneling to deployed backends - -The Server plugin uses the deferred initialization phase to access routes from other plugins. - -#### What it does - -- Starts an Express server (default `host=0.0.0.0`, `port=8000`) -- Mounts plugin routes under `/api//...` -- Adds `/health` endpoint (returns `{ status: "ok" }`) -- Serves frontend: - - **Development** (`NODE_ENV=development`): runs a Vite dev server in middleware mode - - **Production**: auto-detects static frontend directory (checks `dist`, `client/dist`, `build`, `public`, `out`) - -#### Minimal server example - -The smallest valid AppKit server: - -```ts -// server/index.ts -import { createApp, server } from "@databricks/appkit"; - -await createApp({ - plugins: [server()], -}); -``` - -#### Manual server start example - -When you need to extend Express with custom routes: - -```ts -import { createApp, server } from "@databricks/appkit"; - -const appkit = await createApp({ - plugins: [server({ autoStart: false })], -}); - -appkit.server.extend((app) => { - app.get("/custom", (_req, res) => res.json({ ok: true })); -}); - -await appkit.server.start(); -``` - -#### Configuration options - -```ts -import { createApp, server } from "@databricks/appkit"; - -await createApp({ - plugins: [ - server({ - port: 8000, // default: Number(process.env.DATABRICKS_APP_PORT) || 8000 - host: "0.0.0.0", // default: process.env.FLASK_RUN_HOST || "0.0.0.0" - autoStart: true, // default: true - staticPath: "dist", // optional: force a specific static directory - }), - ], -}); -``` - -### Analytics plugin - -Enables SQL query execution against Databricks SQL Warehouses. - -**Key features:** -- File-based SQL queries with automatic type generation -- Parameterized queries with type-safe [SQL helpers](api/appkit/Variable.sql.md) -- JSON and Arrow format support -- Built-in caching and retry logic -- Server-Sent Events (SSE) streaming - -#### Basic usage - -```ts -import { analytics, createApp, server } from "@databricks/appkit"; - -await createApp({ - plugins: [server(), analytics({})], -}); -``` - -#### Where queries live - -- Put `.sql` files in `config/queries/` -- Query key is the filename without `.sql` (e.g. `spend_summary.sql` → `"spend_summary"`) - -#### SQL parameters - -Use `:paramName` placeholders and optionally annotate parameter types using SQL comments: - -```sql --- @param startDate DATE --- @param endDate DATE --- @param limit NUMERIC -SELECT ... -WHERE usage_date BETWEEN :startDate AND :endDate -LIMIT :limit -``` - -**Supported `-- @param` types** (case-insensitive): -- `STRING`, `NUMERIC`, `BOOLEAN`, `DATE`, `TIMESTAMP`, `BINARY` - -#### Server-injected parameters - -`:workspaceId` is **injected by the server** and **must not** be annotated: - -```sql -WHERE workspace_id = :workspaceId -``` - -#### HTTP endpoints - -The analytics plugin exposes these endpoints (mounted under `/api/analytics`): - -- `POST /api/analytics/query/:query_key` -- `POST /api/analytics/users/me/query/:query_key` -- `GET /api/analytics/arrow-result/:jobId` -- `GET /api/analytics/users/me/arrow-result/:jobId` - -#### Format options - -- `format: "JSON"` (default) returns JSON rows -- `format: "ARROW"` returns an Arrow "statement_id" payload over SSE, then the client fetches binary Arrow from `/api/analytics/arrow-result/:jobId` - -### Lakebase plugin - -Provides a PostgreSQL connection pool for Databricks Lakebase Autoscaling with automatic OAuth token refresh. - -**Key features:** -- Standard `pg.Pool` compatible with any PostgreSQL library or ORM -- Automatic OAuth token refresh (1-hour tokens, 2-minute refresh buffer) -- Token caching to minimize API calls -- Built-in OpenTelemetry instrumentation (query duration, pool connections, token refresh) - -#### Basic usage - -```ts -import { createApp, lakebase, server } from "@databricks/appkit"; - -await createApp({ - plugins: [server(), lakebase()], -}); -``` - -#### Environment variables - -The three required environment variables: - -| Variable | Description | -|---|---| -| `PGHOST` | Lakebase host | -| `PGDATABASE` | Database name | -| `LAKEBASE_ENDPOINT` | Endpoint resource path (e.g. `projects/.../branches/.../endpoints/...`) | - -Ensure that those environment variables are set both for local development (`.env` file) and for deployment (`app.yaml` file). - -For the full configuration reference (SSL, pool size, timeouts, logging, ORM examples), see the [`@databricks/lakebase` README](https://github.com/databricks/appkit/blob/main/packages/lakebase/README.md). - -#### Accessing the pool - -After initialization, access Lakebase through the `AppKit.lakebase` object: - -```ts -const AppKit = await createApp({ - plugins: [server(), lakebase()], -}); - -// Direct query (parameterized) -const result = await AppKit.lakebase.query( - "SELECT * FROM orders WHERE user_id = $1", - [userId], -); - -// Raw pg.Pool (for ORMs or advanced usage) -const pool = AppKit.lakebase.pool; - -// ORM-ready config objects -const ormConfig = AppKit.lakebase.getOrmConfig(); // { host, port, database, ... } -const pgConfig = AppKit.lakebase.getPgConfig(); // pg.PoolConfig -``` - -#### Configuration options - -Pass a `pool` object to override any defaults: - -```ts -await createApp({ - plugins: [ - lakebase({ - pool: { - max: 10, // Max pool connections (default: 10) - connectionTimeoutMillis: 5000, // Connection timeout ms (default: 10000) - idleTimeoutMillis: 30000, // Idle connection timeout ms (default: 30000) - }, - }), - ], -}); -``` - -## Execution context and `asUser(req)` - -AppKit manages Databricks authentication via two contexts: - -- **ServiceContext** (singleton): Initialized at app startup with service principal credentials -- **ExecutionContext**: Determined at runtime - either service principal or user context - -### Headers for user context - -- `x-forwarded-user`: required in production; identifies the user -- `x-forwarded-access-token`: required for user token passthrough - -### Using `asUser(req)` for user-scoped operations - -The `asUser(req)` pattern allows plugins to execute operations using the requesting user's credentials: - -```ts -// In a custom plugin route handler -router.post("/users/me/data", async (req, res) => { - // Execute as the user (uses their Databricks permissions) - const result = await this.asUser(req).query("SELECT ..."); - res.json(result); -}); - -// Service principal execution (default) -router.post("/system/data", async (req, res) => { - const result = await this.query("SELECT ..."); - res.json(result); -}); -``` - -### Context helper functions - -Exported from `@databricks/appkit`: - -- `getCurrentUserId()`: Returns user ID in user context, service user ID otherwise -- `getWorkspaceClient()`: Returns the appropriate WorkspaceClient for current context -- `getWarehouseId()`: `Promise` (from `DATABRICKS_WAREHOUSE_ID` or auto-selected in dev) -- `getWorkspaceId()`: `Promise` (from `DATABRICKS_WORKSPACE_ID` or fetched) -- `isInUserContext()`: Returns `true` if currently executing in user context - -### Development mode behavior - -In local development (`NODE_ENV=development`), if `asUser(req)` is called without a user token, it logs a warning and falls back to the service principal. - -## Using plugins - -Configure plugins when creating your AppKit instance: - -```typescript -import { createApp, server, analytics } from "@databricks/appkit"; - -const AppKit = await createApp({ - plugins: [ - server({ port: 8000 }), - analytics(), - ], -}); -``` - -For complete configuration options, see [`createApp`](api/appkit/Function.createApp.md). - -## Plugin management - -AppKit includes a CLI for managing plugins. All commands are available under `npx @databricks/appkit plugin`. - -### Create a plugin - -Scaffold a new plugin interactively: - -```bash -npx @databricks/appkit plugin create -``` - -The wizard walks you through: -- **Placement**: In your repository (e.g. `plugins/my-plugin`) or as a standalone package -- **Metadata**: Name, display name, description -- **Resources**: Which Databricks resources the plugin needs (SQL Warehouse, Secret, etc.) and whether each is required or optional -- **Optional fields**: Author, version, license - -The command generates a complete plugin scaffold with `manifest.json`, TypeScript class, and barrel exports — ready to register in your app. - -### Sync plugin manifests - -Scan your project for plugins and generate `appkit.plugins.json`: - -```bash -npx @databricks/appkit plugin sync --write -``` - -This discovers plugin manifests from installed packages and local imports, then writes a consolidated manifest used by deployment tooling. Plugins referenced in your `createApp({ plugins: [...] })` call are automatically marked as required. - -Use the `--silent` flag in build hooks to suppress output: - -```json -{ - "scripts": { - "sync": "appkit plugin sync --write --silent", - "predev": "npm run sync", - "prebuild": "npm run sync" - } -} -``` - -### Validate manifests - -Check plugin manifests against the JSON schema: - -```bash -# Validate manifest.json in the current directory -npx @databricks/appkit plugin validate - -# Validate specific files or directories -npx @databricks/appkit plugin validate plugins/my-plugin appkit.plugins.json -``` - -The validator auto-detects whether a file is a plugin manifest or a template manifest (from `$schema`) and reports errors with humanized paths and expected values. - -### List plugins - -View registered plugins from `appkit.plugins.json` or scan a directory: - -```bash -# From appkit.plugins.json (default) -npx @databricks/appkit plugin list - -# Scan a directory for plugin folders -npx @databricks/appkit plugin list --dir plugins/ - -# JSON output for scripting -npx @databricks/appkit plugin list --json -``` - -### Add a resource to a plugin - -Interactively add a new resource requirement to an existing plugin manifest: - -```bash -npx @databricks/appkit plugin add-resource - -# Or specify the plugin directory -npx @databricks/appkit plugin add-resource --path plugins/my-plugin -``` - -## Creating custom plugins - -If you need custom API routes or background logic, implement an AppKit plugin. The fastest way is to use the CLI: - -```bash -npx @databricks/appkit plugin create -``` - -For a deeper understanding of the plugin structure, read on. - -### Basic plugin example - -Extend the [`Plugin`](api/appkit/Class.Plugin.md) class and export with `toPlugin()`: - -```typescript -import { Plugin, toPlugin } from "@databricks/appkit"; -import type express from "express"; - -class MyPlugin extends Plugin { - name = "myPlugin"; - - // Define resource requirements in the static manifest - static manifest = { - name: "myPlugin", - displayName: "My Plugin", - description: "A custom plugin", - resources: { - required: [ - { - type: "secret", - alias: "apiKey", - resourceKey: "apiKey", - description: "API key for external service", - permission: "READ", - fields: { - scope: { env: "MY_SECRET_SCOPE", description: "Secret scope" }, - key: { env: "MY_API_KEY", description: "Secret key name" } - } - } - ], - optional: [] - } - }; - - async setup() { - // Initialize your plugin - } - - myCustomMethod() { - // Some implementation - } - - async shutdown() { - // Clean up resources - } - - exports() { - // an object with the methods from this plugin to expose - return { - myCustomMethod: this.myCustomMethod - } - } -} - -export const myPlugin = toPlugin, "myPlugin">( - MyPlugin, - "myPlugin", -); -``` - -### Config-dependent resources - -The manifest defines resources as either `required` (always needed) or `optional` (may be needed). -For resources that become required based on plugin configuration, implement a static -`getResourceRequirements(config)` method: - -```typescript -interface MyPluginConfig extends BasePluginConfig { - enableCaching?: boolean; -} - -class MyPlugin extends Plugin { - name = "myPlugin"; - - static manifest = { - name: "myPlugin", - displayName: "My Plugin", - description: "A plugin with optional caching", - resources: { - required: [ - { type: "sql_warehouse", alias: "warehouse", resourceKey: "sqlWarehouse", description: "Query execution", permission: "CAN_USE", fields: { id: { env: "DATABRICKS_WAREHOUSE_ID" } } } - ], - optional: [ - // Listed as optional in manifest for static analysis - { type: "database", alias: "cache", resourceKey: "cache", description: "Query result caching (if enabled)", permission: "CAN_CONNECT_AND_CREATE", fields: { instance_name: { env: "DATABRICKS_CACHE_INSTANCE" }, database_name: { env: "DATABRICKS_CACHE_DB" } } } - ] - } - }; - - // Runtime: Convert optional resources to required based on config - static getResourceRequirements(config: MyPluginConfig) { - const resources = []; - if (config.enableCaching) { - // When caching is enabled, Database becomes required - resources.push({ - type: "database", - alias: "cache", - resourceKey: "cache", - description: "Query result caching", - permission: "CAN_CONNECT_AND_CREATE", - fields: { - instance_name: { env: "DATABRICKS_CACHE_INSTANCE" }, - database_name: { env: "DATABRICKS_CACHE_DB" }, - }, - required: true // Mark as required at runtime - }); - } - return resources; - } -} -``` - -This pattern allows: -- **Static tools** (CLI, docs) to show all possible resources -- **Runtime validation** to enforce resources based on actual configuration - -### Key extension points - -- **Route injection**: Implement `injectRoutes()` to add custom endpoints using [`IAppRouter`](api/appkit/TypeAlias.IAppRouter.md) -- **Lifecycle hooks**: Override `setup()`, and `shutdown()` methods -- **Shared services**: - - **Cache management**: Access the cache service via `this.cache`. See [`CacheConfig`](api/appkit/Interface.CacheConfig.md) for configuration. - - **Telemetry**: Instrument your plugin with traces and metrics via `this.telemetry`. See [`ITelemetry`](api/appkit/Interface.ITelemetry.md). -- **Execution interceptors**: Use `execute()` and `executeStream()` with [`StreamExecutionSettings`](api/appkit/Interface.StreamExecutionSettings.md) - -**Consuming your plugin programmatically** - -Optionally, you may want to provide a way to consume your plugin programmatically using the AppKit object. -To do that, your plugin needs to implement the `exports` method, returning an object with the methods you want to expose. From the previous example, the plugin could be consumed as follows: - -```ts -const AppKit = await createApp({ - plugins: [ - server({ port: 8000 }), - analytics(), - myPlugin(), - ], -}); - -AppKit.myPlugin.myCustomMethod(); -``` - -See the [`Plugin`](api/appkit/Class.Plugin.md) API reference for complete documentation. - -## Caching - -AppKit provides both global and plugin-level caching capabilities. - -### Global cache configuration - -```ts -await createApp({ - plugins: [server(), analytics({})], - cache: { - enabled: true, - ttl: 3600, // seconds - strictPersistence: false, - }, -}); -``` - -Storage auto-selects **Lakebase V1 (Provisioned) persistent cache when healthy**, otherwise falls back to in-memory. Support for Lakebase Autoscaling coming soon. - -### Plugin-level caching - -Inside a Plugin subclass: - -```ts -const value = await this.cache.getOrExecute( - ["myPlugin", "data", userId], - async () => expensiveWork(), - userKey, - { ttl: 300 }, -); -``` - -## Plugin phases - -Plugins initialize in three phases: - -- **Core**: Reserved for framework-level plugins. Initializes first. -- **Normal**: Default phase for application plugins. Initializes after core. -- **Deferred**: Initializes last with access to other plugin instances via `config.plugins`. Use when your plugin depends on other plugins (e.g., Server Plugin). diff --git a/docs/docs/plugins/_category_.json b/docs/docs/plugins/_category_.json new file mode 100644 index 00000000..599a8656 --- /dev/null +++ b/docs/docs/plugins/_category_.json @@ -0,0 +1,10 @@ +{ + "label": "Plugins", + "position": 3, + "collapsible": true, + "collapsed": false, + "link": { + "type": "doc", + "id": "plugins/index" + } +} diff --git a/docs/docs/plugins/analytics.md b/docs/docs/plugins/analytics.md new file mode 100644 index 00000000..dd44995c --- /dev/null +++ b/docs/docs/plugins/analytics.md @@ -0,0 +1,67 @@ +--- +sidebar_position: 3 +--- + +# Analytics plugin + +Enables SQL query execution against Databricks SQL Warehouses. + +**Key features:** +- File-based SQL queries with automatic type generation +- Parameterized queries with type-safe [SQL helpers](../api/appkit/Variable.sql.md) +- JSON and Arrow format support +- Built-in caching and retry logic +- Server-Sent Events (SSE) streaming + +## Basic usage + +```ts +import { analytics, createApp, server } from "@databricks/appkit"; + +await createApp({ + plugins: [server(), analytics({})], +}); +``` + +## Where queries live + +- Put `.sql` files in `config/queries/` +- Query key is the filename without `.sql` (e.g. `spend_summary.sql` → `"spend_summary"`) + +## SQL parameters + +Use `:paramName` placeholders and optionally annotate parameter types using SQL comments: + +```sql +-- @param startDate DATE +-- @param endDate DATE +-- @param limit NUMERIC +SELECT ... +WHERE usage_date BETWEEN :startDate AND :endDate +LIMIT :limit +``` + +**Supported `-- @param` types** (case-insensitive): +- `STRING`, `NUMERIC`, `BOOLEAN`, `DATE`, `TIMESTAMP`, `BINARY` + +## Server-injected parameters + +`:workspaceId` is **injected by the server** and **must not** be annotated: + +```sql +WHERE workspace_id = :workspaceId +``` + +## HTTP endpoints + +The analytics plugin exposes these endpoints (mounted under `/api/analytics`): + +- `POST /api/analytics/query/:query_key` +- `POST /api/analytics/users/me/query/:query_key` +- `GET /api/analytics/arrow-result/:jobId` +- `GET /api/analytics/users/me/arrow-result/:jobId` + +## Format options + +- `format: "JSON"` (default) returns JSON rows +- `format: "ARROW"` returns an Arrow "statement_id" payload over SSE, then the client fetches binary Arrow from `/api/analytics/arrow-result/:jobId` diff --git a/docs/docs/plugins/assets/lakebase-setup/step-1.png b/docs/docs/plugins/assets/lakebase-setup/step-1.png new file mode 100644 index 0000000000000000000000000000000000000000..168ab7bdfbb552c526a37ad996e3cda7d45678e2 GIT binary patch literal 43577 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

{R{~>X?Po$=ze*q>ZkWI- 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 HIQ+i>p?|b6 literal 0 HcmV?d00001 diff --git a/docs/docs/plugins/assets/lakebase-setup/step-2.png b/docs/docs/plugins/assets/lakebase-setup/step-2.png new file mode 100644 index 0000000000000000000000000000000000000000..5d99b912c38c2fe9a4f54addff539e4be25dd38e GIT binary patch literal 61813 zcmeFZbyytB*658(7%bS}mf$i-&|!c;AXu;@KyV!h?hNiOL4pKN(BKl>We6T1!F`b6 z?sjMIbKY~#`|f?e?|JS&_n$k{^GtPBuUcJet*+{>r+yuw_DUZA5!E9U6cl`gm$Dit zC>R(hD5&E&SjZeN5lT}n#KpFiex*OIL~WYxaH>lqhHCQl9w$sxMMG%2+CVk{wC zV)xp`Xx}@-%L0fMev$h8H3`alS5i8cAN^8m}C?NkeO`Xim?VK&`UFM;~oG2)05UbbPF4`)}Vy5=CJjQ1BCgwaIwhn)Y zpnyHZkV#u}7h?twTN^uPF%Jo*KaUVYrvJ$1Wn%dA5Ep9+CT$fp1{r%Na|R(E5D$n6 z@`! z82qQ2zm)v@ME@cA#@XCS#@-ew=mPn-TmC8hpN0QZ@K2T6|5nKd;urZ(o&QnvAEJM> zK}^-j3aQTc48|1yf!+d91 ztaf*7aWQWJ-5kk$<2JVh%UbX{P-f|G>3<^1%9>`O*(wr&6Yl?)tpo5P=L+Cj-=srK zg!-2)Kq{vc7^aZO(s+b`H#*+icLn3xRX<3;21ut$r!mEN(3lwhvi&f_dCi9tO)Wkd zL-lOnD2x0s^ItK3|{#`AlTLGUiwjh;Jv)x#)z3j`D{hx~dP;CTfBm$uI+SQv6CYLWL3p5JZ&NaO)d)G+L z{Vq5skyVv|8ozpLd7963z9)ht>P0T%Z`#Iy7V|->hH=SP{8<_=05wz0-A!N^?0o!s z`+)D^mZSw>27KB3CFpM?fBeQF6(Xz6_-4PfILtq1b1pE&8j5~@e|zUH?0NcIZ;I{1 zUz~$S&ke`|!C zqsKT{sONy9eg1$_T_&E@q`!#?e;mPAXq^llSbb2U>x^TGCy&zBTw+p#k4$`Z-|9u5H*{x~p zVnOfRJ7Uc$ni5M>7TCK;w{Klbo<^t1H1PlRJPo0XZ~>9LQE?h=KMbVa?kkE>p!%v>4Jm|VXNInQdXs!4F-|CP z`9mhAe4aYtjZEIz#gbpM*M95N9b&G!rK{%Z=Y(o=VK$8A;HiL11HZ-b#3GA7<1)8o zkt_&MT05?2xBgLU1V2jT;TYdqzXi5j(SGj)&2UZjI%vIke!X{VO%x}#%~o%h4QV_f z!EU+QNY`IFn{vnFZE^5!c)P^g@SEvkwxpto?5*CI?XGy}^#}V~hTA|qUKeWn+IZ{9 zQk`#!QW3kqN>b8GbnD+6rn_}Qvwb$o8_(a>e`ktnSWng$;(pmmcQYtVMB%xw#MRcY z^CMTLHSgI-`@2Lz@>DpSF`p27bj!-mOi(a~{^aIBcX>Gw|HXw+r&Ua|)@K z8iicwftJ-SpvM&?!wI2A=^uUdGfa)#E+j4*%##ho06*`~LYo#_y;7pD2P@i~+!uW6 zb^Th;6hl?8DqmSw^^%v={}BvV>8Jx|!t={+)4pEyzduK@s801CP#AcRwVq$^*tNP& zx!U@8>FL6z>i2BtY8{ohs$}#Y8L&wGoOPA9gRG;c*eIn)#>H z6OayK1Vuf-z8tiijO>tKm}iiRFTs}vziAoji>Ra-nSF-1?M{#Bug;Ms-Vuo8L=wY< z4$R$Gt~SFMbf(_X=w!=;61Wy-`g-Cx-NQB;%WFpI+BR1lBkZA&W4*+#R>wH2<4pU} z2G!ZZ?NiOu+-%?LVqJ?g^LgVi8jWx&^c!0D#Vv!QyB(^Miv9Ch=g}_Fn*_Hw02-fm zVSl_l&59>?quFe+Lur$()Vu3mCcnLJQ#8oo#JAMn!4I9MdC2Femty6Dt7d5Resn4# zgj^4FTRtoae|2hj%8OGGy9g`HoENjM&<{Va<}AmtN?d$mz_`%lxdaO31KAO)%KY5?3 z67i$FM2&8~wgty9S{ke-5{|B0ife`U8&p@F)ow3H(E(^-H=U$@bGG%F)F30|C<7u= zj0{ntW8H7}345(8dXwQiPkKOh*x_>#A}v%S0L_3E=+?>;3SZ1SPYGR%HQrN7UW#

ghjYf4zJ7Bb!=s_T^ETGktXCW?&L9HN9m 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∓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�u^1I)f-dy5rXX2R{ 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 literal 0 HcmV?d00001 diff --git a/docs/docs/plugins/assets/lakebase-setup/step-5.png b/docs/docs/plugins/assets/lakebase-setup/step-5.png new file mode 100644 index 0000000000000000000000000000000000000000..3fc65dce07f4143046d31fafded76fd776591152 GIT binary patch literal 108930 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%0A?V;K~H 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 literal 0 HcmV?d00001 diff --git a/docs/docs/plugins/caching.md b/docs/docs/plugins/caching.md new file mode 100644 index 00000000..9cb94d5e --- /dev/null +++ b/docs/docs/plugins/caching.md @@ -0,0 +1,35 @@ +--- +sidebar_position: 7 +--- + +# Caching + +AppKit provides both global and plugin-level caching capabilities. + +## Global cache configuration + +```ts +await createApp({ + plugins: [server(), analytics({})], + cache: { + enabled: true, + ttl: 3600, // seconds + strictPersistence: false, + }, +}); +``` + +Storage auto-selects **Lakebase V1 (Provisioned) persistent cache when healthy**, otherwise falls back to in-memory. Support for Lakebase Autoscaling coming soon. + +## Plugin-level caching + +Inside a Plugin subclass: + +```ts +const value = await this.cache.getOrExecute( + ["myPlugin", "data", userId], + async () => expensiveWork(), + userKey, + { ttl: 300 }, +); +``` diff --git a/docs/docs/plugins/custom-plugins.md b/docs/docs/plugins/custom-plugins.md new file mode 100644 index 00000000..0f79de96 --- /dev/null +++ b/docs/docs/plugins/custom-plugins.md @@ -0,0 +1,151 @@ +--- +sidebar_position: 6 +--- + +# Creating custom plugins + +If you need custom API routes or background logic, implement an AppKit plugin. + +## Basic plugin example + +Extend the [`Plugin`](../api/appkit/Class.Plugin.md) class and export with `toPlugin()`: + +```typescript +import { Plugin, toPlugin } from "@databricks/appkit"; +import type express from "express"; + +class MyPlugin extends Plugin { + name = "myPlugin"; + + // Define resource requirements in the static manifest + static manifest = { + name: "myPlugin", + displayName: "My Plugin", + description: "A custom plugin", + resources: { + required: [ + { + type: "secret", + alias: "apiKey", + resourceKey: "apiKey", + description: "API key for external service", + permission: "READ", + fields: { + scope: { env: "MY_SECRET_SCOPE", description: "Secret scope" }, + key: { env: "MY_API_KEY", description: "Secret key name" } + } + } + ], + optional: [] + } + }; + + async setup() { + // Initialize your plugin + } + + myCustomMethod() { + // Some implementation + } + + async shutdown() { + // Clean up resources + } + + exports() { + // an object with the methods from this plugin to expose + return { + myCustomMethod: this.myCustomMethod + } + } +} + +export const myPlugin = toPlugin, "myPlugin">( + MyPlugin, + "myPlugin", +); +``` + +## Config-dependent resources + +The manifest defines resources as either `required` (always needed) or `optional` (may be needed). +For resources that become required based on plugin configuration, implement a static +`getResourceRequirements(config)` method: + +```typescript +interface MyPluginConfig extends BasePluginConfig { + enableCaching?: boolean; +} + +class MyPlugin extends Plugin { + name = "myPlugin"; + + static manifest = { + name: "myPlugin", + displayName: "My Plugin", + description: "A plugin with optional caching", + resources: { + required: [ + { type: "sql_warehouse", alias: "warehouse", resourceKey: "sqlWarehouse", description: "Query execution", permission: "CAN_USE", fields: { id: { env: "DATABRICKS_WAREHOUSE_ID" } } } + ], + optional: [ + // Listed as optional in manifest for static analysis + { type: "database", alias: "cache", resourceKey: "cache", description: "Query result caching (if enabled)", permission: "CAN_CONNECT_AND_CREATE", fields: { instance_name: { env: "DATABRICKS_CACHE_INSTANCE" }, database_name: { env: "DATABRICKS_CACHE_DB" } } } + ] + } + }; + + // Runtime: Convert optional resources to required based on config + static getResourceRequirements(config: MyPluginConfig) { + const resources = []; + if (config.enableCaching) { + // When caching is enabled, Database becomes required + resources.push({ + type: "database", + alias: "cache", + resourceKey: "cache", + description: "Query result caching", + permission: "CAN_CONNECT_AND_CREATE", + fields: { + instance_name: { env: "DATABRICKS_CACHE_INSTANCE" }, + database_name: { env: "DATABRICKS_CACHE_DB" }, + }, + required: true // Mark as required at runtime + }); + } + return resources; + } +} +``` + +This pattern allows: +- **Static tools** (CLI, docs) to show all possible resources +- **Runtime validation** to enforce resources based on actual configuration + +## Key extension points + +- **Route injection**: Implement `injectRoutes()` to add custom endpoints using [`IAppRouter`](../api/appkit/TypeAlias.IAppRouter.md) +- **Lifecycle hooks**: Override `setup()`, and `shutdown()` methods +- **Shared services**: + - **Cache management**: Access the cache service via `this.cache`. See [`CacheConfig`](../api/appkit/Interface.CacheConfig.md) for configuration. + - **Telemetry**: Instrument your plugin with traces and metrics via `this.telemetry`. See [`ITelemetry`](../api/appkit/Interface.ITelemetry.md). +- **Execution interceptors**: Use `execute()` and `executeStream()` with [`StreamExecutionSettings`](../api/appkit/Interface.StreamExecutionSettings.md) + +**Consuming your plugin programmatically** + +Optionally, you may want to provide a way to consume your plugin programmatically using the AppKit object. +To do that, your plugin needs to implement the `exports` method, returning an object with the methods you want to expose. From the previous example, the plugin could be consumed as follows: + +```ts +const AppKit = await createApp({ + plugins: [ + server({ port: 8000 }), + analytics(), + myPlugin(), + ], +}); + +AppKit.myPlugin.myCustomMethod(); +``` + +See the [`Plugin`](../api/appkit/Class.Plugin.md) API reference for complete documentation. diff --git a/docs/docs/plugins/execution-context.md b/docs/docs/plugins/execution-context.md new file mode 100644 index 00000000..10da4d50 --- /dev/null +++ b/docs/docs/plugins/execution-context.md @@ -0,0 +1,48 @@ +--- +sidebar_position: 5 +--- + +# Execution context + +AppKit manages Databricks authentication via two contexts: + +- **ServiceContext** (singleton): Initialized at app startup with service principal credentials +- **ExecutionContext**: Determined at runtime - either service principal or user context + +## Headers for user context + +- `x-forwarded-user`: required in production; identifies the user +- `x-forwarded-access-token`: required for user token passthrough + +## Using `asUser(req)` for user-scoped operations + +The `asUser(req)` pattern allows plugins to execute operations using the requesting user's credentials: + +```ts +// In a custom plugin route handler +router.post("/users/me/data", async (req, res) => { + // Execute as the user (uses their Databricks permissions) + const result = await this.asUser(req).query("SELECT ..."); + res.json(result); +}); + +// Service principal execution (default) +router.post("/system/data", async (req, res) => { + const result = await this.query("SELECT ..."); + res.json(result); +}); +``` + +## Context helper functions + +Exported from `@databricks/appkit`: + +- `getCurrentUserId()`: Returns user ID in user context, service user ID otherwise +- `getWorkspaceClient()`: Returns the appropriate WorkspaceClient for current context +- `getWarehouseId()`: `Promise` (from `DATABRICKS_WAREHOUSE_ID` or auto-selected in dev) +- `getWorkspaceId()`: `Promise` (from `DATABRICKS_WORKSPACE_ID` or fetched) +- `isInUserContext()`: Returns `true` if currently executing in user context + +## Development mode behavior + +In local development (`NODE_ENV=development`), if `asUser(req)` is called without a user token, it logs a warning and falls back to the service principal. diff --git a/docs/docs/plugins/index.md b/docs/docs/plugins/index.md new file mode 100644 index 00000000..a74668cb --- /dev/null +++ b/docs/docs/plugins/index.md @@ -0,0 +1,34 @@ +--- +sidebar_position: 1 +--- + +# Plugins + +Plugins are modular extensions that add capabilities to your AppKit application. They follow a defined lifecycle and have access to shared services like caching, telemetry, and streaming. + +For complete API documentation, see the [`Plugin`](../api/appkit/Class.Plugin.md) class reference. + +## Using plugins + +Configure plugins when creating your AppKit instance: + +```typescript +import { createApp, server, analytics } from "@databricks/appkit"; + +const AppKit = await createApp({ + plugins: [ + server({ port: 8000 }), + analytics(), + ], +}); +``` + +For complete configuration options, see [`createApp`](../api/appkit/Function.createApp.md). + +## Plugin phases + +Plugins initialize in three phases: + +- **Core**: Reserved for framework-level plugins. Initializes first. +- **Normal**: Default phase for application plugins. Initializes after core. +- **Deferred**: Initializes last with access to other plugin instances via `config.plugins`. Use when your plugin depends on other plugins (e.g., Server Plugin). diff --git a/docs/docs/plugins/lakebase.md b/docs/docs/plugins/lakebase.md new file mode 100644 index 00000000..e5f5db0f --- /dev/null +++ b/docs/docs/plugins/lakebase.md @@ -0,0 +1,171 @@ +--- +sidebar_position: 4 +--- + +# Lakebase plugin + +Provides a PostgreSQL connection pool for Databricks Lakebase Autoscaling with automatic OAuth token refresh. + +**Key features:** +- Standard `pg.Pool` compatible with any PostgreSQL library or ORM +- Automatic OAuth token refresh (1-hour tokens, 2-minute refresh buffer) +- Token caching to minimize API calls +- Built-in OpenTelemetry instrumentation (query duration, pool connections, token refresh) + +## Setting up Lakebase + +Before using the plugin, you need to connect your Databricks App's service principal to your Lakebase database. + +### 1. Find your app's service principal + +Create a Databricks App from the UI (`Compute > Apps > Create App > Create a custom app`). Navigate to the **Environment** tab and note the `DATABRICKS_CLIENT_ID` value — this is the service principal that will connect to your Lakebase database. + +![App environment tab](./assets/lakebase-setup/step-1.png) + +### 2. Find your Project ID and Branch ID + +Create a new Lakebase Postgres Autoscaling project. Navigate to your Lakebase project's branch details and switch to the **Compute** tab. Note the **Project ID** and **Branch ID** from the URL. + +![Branch details](./assets/lakebase-setup/step-2.png) + +### 3. Find your endpoint + +Use the Databricks CLI to list endpoints for the branch. Note the `name` field from the output — this is your `LAKEBASE_ENDPOINT` value. + +```bash +databricks postgres list-endpoints projects/{project-id}/branches/{branch-id} +``` + +Example output: + +```json +[ + { + "create_time": "2026-02-19T12:13:02Z", + "name": "projects/{project-id}/branches/{branch-id}/endpoints/primary" + } +] +``` + +### 4. Get connection parameters + +Click the **Connect** button on your Lakebase branch and copy the `PGHOST` and `PGDATABASE` values for later. + +![Connect dialog](./assets/lakebase-setup/step-4.png) + +### 5. Grant access to the service principal + +Navigate to the **SQL Editor** tab on your Lakebase branch. Run the following SQL against the `databricks_postgres` database, replacing `` with the value from step 1 everywhere it appears: + +```sql +-- 1. Create the extension and role +CREATE EXTENSION IF NOT EXISTS databricks_auth; +SELECT databricks_create_role('', 'SERVICE_PRINCIPAL'); + +-- 2. Basic connection & usage +GRANT CONNECT ON DATABASE "databricks_postgres" TO ""; +GRANT ALL ON SCHEMA public TO ""; + +-- 3. Grant on existing objects +GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO ""; +GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO ""; +GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public TO ""; +GRANT ALL PRIVILEGES ON ALL PROCEDURES IN SCHEMA public TO ""; + +-- 4. Grant on future objects +-- NOTE: This applies to objects created by the user running this script. +ALTER DEFAULT PRIVILEGES IN SCHEMA public + GRANT ALL ON TABLES TO ""; +ALTER DEFAULT PRIVILEGES IN SCHEMA public + GRANT ALL ON SEQUENCES TO ""; +ALTER DEFAULT PRIVILEGES IN SCHEMA public + GRANT ALL ON FUNCTIONS TO ""; +ALTER DEFAULT PRIVILEGES IN SCHEMA public + GRANT ALL ON ROUTINES TO ""; +``` + +![SQL Editor](./assets/lakebase-setup/step-5.png) + +### 6. Verify the role + +Navigate to the **Roles & Databases** tab and confirm the role is visible. You may need to fully refresh the page. + +![Roles & Databases tab](./assets/lakebase-setup/step-6.png) + +## Basic usage + +```ts +import { createApp, lakebase, server } from "@databricks/appkit"; + +await createApp({ + plugins: [server(), lakebase()], +}); +``` + +## Environment variables + +The required environment variables: + +| Variable | Description | +|---|---| +| `PGHOST` | Lakebase host | +| `PGDATABASE` | Database name | +| `LAKEBASE_ENDPOINT` | Endpoint resource path (e.g. `projects/.../branches/.../endpoints/...`) | +| `PGSSLMODE` | TLS mode — set to `require` | + +Ensure that those environment variables are set both for local development (`.env` file) and for deployment (`app.yaml` file): + +```yaml +env: + - name: LAKEBASE_ENDPOINT + value: projects/{project-id}/branches/{branch-id}/endpoints/primary + - name: PGHOST + value: {your-lakebase-host} + - name: PGDATABASE + value: databricks_postgres + - name: PGSSLMODE + value: require +``` + +For the full configuration reference (SSL, pool size, timeouts, logging, ORM examples), see the [`@databricks/lakebase` README](https://github.com/databricks/appkit/blob/main/packages/lakebase/README.md). + +## Accessing the pool + +After initialization, access Lakebase through the `AppKit.lakebase` object: + +```ts +const AppKit = await createApp({ + plugins: [server(), lakebase()], +}); + +// Direct query (parameterized) +const result = await AppKit.lakebase.query( + "SELECT * FROM orders WHERE user_id = $1", + [userId], +); + +// Raw pg.Pool (for ORMs or advanced usage) +const pool = AppKit.lakebase.pool; + +// ORM-ready config objects +const ormConfig = AppKit.lakebase.getOrmConfig(); // { host, port, database, ... } +const pgConfig = AppKit.lakebase.getPgConfig(); // pg.PoolConfig +``` + +## Configuration options + +Pass a `pool` object to override any defaults: + +```ts +await createApp({ + plugins: [ + lakebase({ + pool: { + max: 10, // Max pool connections (default: 10) + connectionTimeoutMillis: 5000, // Connection timeout ms (default: 10000) + idleTimeoutMillis: 30000, // Idle connection timeout ms (default: 30000) + }, + }), + ], +}); +``` diff --git a/docs/docs/plugins/plugin-management.md b/docs/docs/plugins/plugin-management.md new file mode 100644 index 00000000..1fa25068 --- /dev/null +++ b/docs/docs/plugins/plugin-management.md @@ -0,0 +1,85 @@ +--- +sidebar_position: 6 +--- + +# Plugin management + +AppKit includes a CLI for managing plugins. All commands are available under `npx @databricks/appkit plugin`. + +## Create a plugin + +Scaffold a new plugin interactively: + +```bash +npx @databricks/appkit plugin create +``` + +The wizard walks you through: +- **Placement**: In your repository (e.g. `plugins/my-plugin`) or as a standalone package +- **Metadata**: Name, display name, description +- **Resources**: Which Databricks resources the plugin needs (SQL Warehouse, Secret, etc.) and whether each is required or optional +- **Optional fields**: Author, version, license + +The command generates a complete plugin scaffold with `manifest.json`, TypeScript class, and barrel exports — ready to register in your app. + +## Sync plugin manifests + +Scan your project for plugins and generate `appkit.plugins.json`: + +```bash +npx @databricks/appkit plugin sync --write +``` + +This discovers plugin manifests from installed packages and local imports, then writes a consolidated manifest used by deployment tooling. Plugins referenced in your `createApp({ plugins: [...] })` call are automatically marked as required. + +Use the `--silent` flag in build hooks to suppress output: + +```json +{ + "scripts": { + "sync": "appkit plugin sync --write --silent", + "predev": "npm run sync", + "prebuild": "npm run sync" + } +} +``` + +## Validate manifests + +Check plugin manifests against the JSON schema: + +```bash +# Validate manifest.json in the current directory +npx @databricks/appkit plugin validate + +# Validate specific files or directories +npx @databricks/appkit plugin validate plugins/my-plugin appkit.plugins.json +``` + +The validator auto-detects whether a file is a plugin manifest or a template manifest (from `$schema`) and reports errors with humanized paths and expected values. + +## List plugins + +View registered plugins from `appkit.plugins.json` or scan a directory: + +```bash +# From appkit.plugins.json (default) +npx @databricks/appkit plugin list + +# Scan a directory for plugin folders +npx @databricks/appkit plugin list --dir plugins/ + +# JSON output for scripting +npx @databricks/appkit plugin list --json +``` + +## Add a resource to a plugin + +Interactively add a new resource requirement to an existing plugin manifest: + +```bash +npx @databricks/appkit plugin add-resource + +# Or specify the plugin directory +npx @databricks/appkit plugin add-resource --path plugins/my-plugin +``` diff --git a/docs/docs/plugins/server.md b/docs/docs/plugins/server.md new file mode 100644 index 00000000..b43c00e4 --- /dev/null +++ b/docs/docs/plugins/server.md @@ -0,0 +1,72 @@ +--- +sidebar_position: 2 +--- + +# Server plugin + +Provides HTTP server capabilities with development and production modes. + +**Key features:** +- Express server for REST APIs +- Vite dev server with hot module reload +- Static file serving for production +- Remote tunneling to deployed backends + +The Server plugin uses the deferred initialization phase to access routes from other plugins. + +## What it does + +- Starts an Express server (default `host=0.0.0.0`, `port=8000`) +- Mounts plugin routes under `/api//...` +- Adds `/health` endpoint (returns `{ status: "ok" }`) +- Serves frontend: + - **Development** (`NODE_ENV=development`): runs a Vite dev server in middleware mode + - **Production**: auto-detects static frontend directory (checks `dist`, `client/dist`, `build`, `public`, `out`) + +## Minimal server example + +The smallest valid AppKit server: + +```ts +// server/index.ts +import { createApp, server } from "@databricks/appkit"; + +await createApp({ + plugins: [server()], +}); +``` + +## Manual server start example + +When you need to extend Express with custom routes: + +```ts +import { createApp, server } from "@databricks/appkit"; + +const appkit = await createApp({ + plugins: [server({ autoStart: false })], +}); + +appkit.server.extend((app) => { + app.get("/custom", (_req, res) => res.json({ ok: true })); +}); + +await appkit.server.start(); +``` + +## Configuration options + +```ts +import { createApp, server } from "@databricks/appkit"; + +await createApp({ + plugins: [ + server({ + port: 8000, // default: Number(process.env.DATABRICKS_APP_PORT) || 8000 + host: "0.0.0.0", // default: process.env.FLASK_RUN_HOST || "0.0.0.0" + autoStart: true, // default: true + staticPath: "dist", // optional: force a specific static directory + }), + ], +}); +``` From 9768d768ce74dc70e128fcdcd5ef619ee509e3c8 Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Tue, 24 Feb 2026 12:24:08 +0100 Subject: [PATCH 3/9] chore: regenerate types --- docs/docs/plugins/caching.md | 2 +- docs/docs/plugins/custom-plugins.md | 10 ++++++++-- template/appkit.plugins.json | 10 ++++++++++ 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/docs/docs/plugins/caching.md b/docs/docs/plugins/caching.md index 9cb94d5e..d6cba4c3 100644 --- a/docs/docs/plugins/caching.md +++ b/docs/docs/plugins/caching.md @@ -1,5 +1,5 @@ --- -sidebar_position: 7 +sidebar_position: 8 --- # Caching diff --git a/docs/docs/plugins/custom-plugins.md b/docs/docs/plugins/custom-plugins.md index 0f79de96..59a1ce51 100644 --- a/docs/docs/plugins/custom-plugins.md +++ b/docs/docs/plugins/custom-plugins.md @@ -1,10 +1,16 @@ --- -sidebar_position: 6 +sidebar_position: 7 --- # Creating custom plugins -If you need custom API routes or background logic, implement an AppKit plugin. +If you need custom API routes or background logic, implement an AppKit plugin. The fastest way is to use the CLI: + +```bash +npx @databricks/appkit plugin create +``` + +For a deeper understanding of the plugin structure, read on. ## Basic plugin example diff --git a/template/appkit.plugins.json b/template/appkit.plugins.json index 5d5c7a10..f87079ab 100644 --- a/template/appkit.plugins.json +++ b/template/appkit.plugins.json @@ -26,6 +26,16 @@ "optional": [] } }, + "lakebase": { + "name": "lakebase", + "displayName": "Lakebase", + "description": "SQL query execution against Databricks Lakebase Autoscaling", + "package": "@databricks/appkit", + "resources": { + "required": [], + "optional": [] + } + }, "server": { "name": "server", "displayName": "Server Plugin", From 26748b739afe9f86d04174587496ad622d2a725f Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Tue, 24 Feb 2026 15:16:02 +0100 Subject: [PATCH 4/9] chore: use biome-ignore comments --- packages/appkit/src/plugins/lakebase/lakebase.ts | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/packages/appkit/src/plugins/lakebase/lakebase.ts b/packages/appkit/src/plugins/lakebase/lakebase.ts index a72ef4f6..e8a1f18c 100644 --- a/packages/appkit/src/plugins/lakebase/lakebase.ts +++ b/packages/appkit/src/plugins/lakebase/lakebase.ts @@ -63,7 +63,6 @@ export class LakebasePlugin extends Plugin { * @param text - SQL query string, using `$1`, `$2`, ... placeholders * @param values - Parameter values corresponding to placeholders * @returns Query result with typed rows - * @throws If the pool has not been initialized (i.e. `setup()` was not called) * * @example * ```ts @@ -77,10 +76,8 @@ export class LakebasePlugin extends Plugin { text: string, values?: unknown[], ): Promise> { - if (!this.pool) { - throw new Error("Lakebase pool not initialized. Was setup() called?"); - } - return this.pool.query(text, values); + // biome-ignore lint/style/noNonNullAssertion: pool is guaranteed non-null after setup(), which AppKit always awaits before exposing the plugin API + return this.pool!.query(text, values); } /** @@ -107,13 +104,9 @@ export class LakebasePlugin extends Plugin { * - `getPgConfig()` — Returns a `pg.PoolConfig` object for manual pool construction */ exports() { - const pool = this.pool; - if (!pool) { - throw new Error("Lakebase pool not initialized. Was setup() called?"); - } - return { - pool: pool, + // biome-ignore lint/style/noNonNullAssertion: pool is guaranteed non-null after setup(), which AppKit always awaits before exposing the plugin API + pool: this.pool!, query: this.query.bind(this), getOrmConfig: () => getLakebaseOrmConfig(this.config.pool), getPgConfig: () => getLakebasePgConfig(this.config.pool), From ea1a2e9f887f7e880835eb74b8d81ce3f01b9a72 Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Tue, 24 Feb 2026 18:19:27 +0100 Subject: [PATCH 5/9] chore: fix docs build --- docs/docs/api/appkit/Class.LakebasePlugin.md | 8 -------- 1 file changed, 8 deletions(-) diff --git a/docs/docs/api/appkit/Class.LakebasePlugin.md b/docs/docs/api/appkit/Class.LakebasePlugin.md index 4a03621e..fd612da2 100644 --- a/docs/docs/api/appkit/Class.LakebasePlugin.md +++ b/docs/docs/api/appkit/Class.LakebasePlugin.md @@ -407,10 +407,6 @@ Executes a parameterized SQL query against the Lakebase pool. Query result with typed rows -###### Throws - -If the pool has not been initialized (i.e. `setup()` was not called) - ###### Example ```ts @@ -491,10 +487,6 @@ Executes a parameterized SQL query against the Lakebase pool. Query result with typed rows -#### Throws - -If the pool has not been initialized (i.e. `setup()` was not called) - #### Example ```ts From b96e2bdf69d99102981d7f3ecdec3f0ed8a9f9ec Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Wed, 25 Feb 2026 09:40:54 +0100 Subject: [PATCH 6/9] chore: add a note about having the plugin experimental --- docs/docs/plugins/lakebase.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/docs/plugins/lakebase.md b/docs/docs/plugins/lakebase.md index e5f5db0f..e1d3ec12 100644 --- a/docs/docs/plugins/lakebase.md +++ b/docs/docs/plugins/lakebase.md @@ -4,6 +4,10 @@ sidebar_position: 4 # Lakebase plugin +:::info +Currently, the Lakebase plugin currently requires a one-time manual setup to connect your Databricks App with your Lakebase database. An automated setup process is planned for an upcoming future release. +::: + Provides a PostgreSQL connection pool for Databricks Lakebase Autoscaling with automatic OAuth token refresh. **Key features:** From 0c616c547fe8088f42c987c23af5f7c08186e17b Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Wed, 25 Feb 2026 11:05:19 +0100 Subject: [PATCH 7/9] chore: bring back the "onSetupMessage" --- docs/static/schemas/plugin-manifest.schema.json | 4 ++++ docs/static/schemas/template-plugins.schema.json | 4 ++++ packages/appkit/src/plugins/lakebase/manifest.json | 1 + .../shared/src/cli/commands/plugin/manifest-types.ts | 1 + packages/shared/src/cli/commands/plugin/sync/sync.ts | 9 +++++++++ packages/shared/src/plugin.ts | 1 + packages/shared/src/schemas/plugin-manifest.schema.json | 4 ++++ packages/shared/src/schemas/template-plugins.schema.json | 4 ++++ template/appkit.plugins.json | 3 ++- 9 files changed, 30 insertions(+), 1 deletion(-) diff --git a/docs/static/schemas/plugin-manifest.schema.json b/docs/static/schemas/plugin-manifest.schema.json index e4d43c8f..465498b2 100644 --- a/docs/static/schemas/plugin-manifest.schema.json +++ b/docs/static/schemas/plugin-manifest.schema.json @@ -86,6 +86,10 @@ "type": "string", "description": "SPDX license identifier", "examples": ["Apache-2.0", "MIT"] + }, + "onSetupMessage": { + "type": "string", + "description": "Message displayed to the user after project initialization. Use this to inform about manual setup steps (e.g. environment variables, resource provisioning)." } }, "additionalProperties": false, diff --git a/docs/static/schemas/template-plugins.schema.json b/docs/static/schemas/template-plugins.schema.json index 9713e9f6..290edd05 100644 --- a/docs/static/schemas/template-plugins.schema.json +++ b/docs/static/schemas/template-plugins.schema.json @@ -65,6 +65,10 @@ "default": false, "description": "When true, this plugin is required by the template and cannot be deselected during CLI init. The user will only be prompted to configure its resources. When absent or false, the plugin is optional and the user can choose whether to include it." }, + "onSetupMessage": { + "type": "string", + "description": "Message displayed to the user after project initialization. Use this to inform about manual setup steps (e.g. environment variables, resource provisioning)." + }, "resources": { "type": "object", "required": ["required", "optional"], diff --git a/packages/appkit/src/plugins/lakebase/manifest.json b/packages/appkit/src/plugins/lakebase/manifest.json index 17415d5b..889d9e13 100644 --- a/packages/appkit/src/plugins/lakebase/manifest.json +++ b/packages/appkit/src/plugins/lakebase/manifest.json @@ -3,6 +3,7 @@ "name": "lakebase", "displayName": "Lakebase", "description": "SQL query execution against Databricks Lakebase Autoscaling", + "onSetupMessage": "Configure environment variables before running or deploying the app.\nSee: https://databricks.github.io/appkit/docs/plugins/lakebase", "resources": { "required": [], "optional": [] diff --git a/packages/shared/src/cli/commands/plugin/manifest-types.ts b/packages/shared/src/cli/commands/plugin/manifest-types.ts index 420a09b3..9dfb041e 100644 --- a/packages/shared/src/cli/commands/plugin/manifest-types.ts +++ b/packages/shared/src/cli/commands/plugin/manifest-types.ts @@ -27,6 +27,7 @@ export interface PluginManifest { optional: ResourceRequirement[]; }; config?: { schema: unknown }; + onSetupMessage?: string; } export interface TemplatePlugin extends Omit { diff --git a/packages/shared/src/cli/commands/plugin/sync/sync.ts b/packages/shared/src/cli/commands/plugin/sync/sync.ts index 5d00b656..1ec5e9e3 100644 --- a/packages/shared/src/cli/commands/plugin/sync/sync.ts +++ b/packages/shared/src/cli/commands/plugin/sync/sync.ts @@ -278,6 +278,9 @@ function discoverLocalPlugins( description: manifest.description, package: `./${relativePath}`, resources: manifest.resources, + ...(manifest.onSetupMessage && { + onSetupMessage: manifest.onSetupMessage, + }), }; } catch (error) { console.warn( @@ -358,6 +361,9 @@ function scanForPlugins( description: manifest.description, package: packageName, resources: manifest.resources, + ...(manifest.onSetupMessage && { + onSetupMessage: manifest.onSetupMessage, + }), }; } } @@ -400,6 +406,9 @@ function scanPluginsDir( description: manifest.description, package: packageName, resources: manifest.resources, + ...(manifest.onSetupMessage && { + onSetupMessage: manifest.onSetupMessage, + }), }; } } catch (error) { diff --git a/packages/shared/src/plugin.ts b/packages/shared/src/plugin.ts index 54d8f583..b29933b3 100644 --- a/packages/shared/src/plugin.ts +++ b/packages/shared/src/plugin.ts @@ -84,6 +84,7 @@ export interface PluginManifest { config?: { schema: JSONSchema7; }; + onSetupMessage?: string; author?: string; version?: string; repository?: string; diff --git a/packages/shared/src/schemas/plugin-manifest.schema.json b/packages/shared/src/schemas/plugin-manifest.schema.json index e4d43c8f..465498b2 100644 --- a/packages/shared/src/schemas/plugin-manifest.schema.json +++ b/packages/shared/src/schemas/plugin-manifest.schema.json @@ -86,6 +86,10 @@ "type": "string", "description": "SPDX license identifier", "examples": ["Apache-2.0", "MIT"] + }, + "onSetupMessage": { + "type": "string", + "description": "Message displayed to the user after project initialization. Use this to inform about manual setup steps (e.g. environment variables, resource provisioning)." } }, "additionalProperties": false, diff --git a/packages/shared/src/schemas/template-plugins.schema.json b/packages/shared/src/schemas/template-plugins.schema.json index 9713e9f6..290edd05 100644 --- a/packages/shared/src/schemas/template-plugins.schema.json +++ b/packages/shared/src/schemas/template-plugins.schema.json @@ -65,6 +65,10 @@ "default": false, "description": "When true, this plugin is required by the template and cannot be deselected during CLI init. The user will only be prompted to configure its resources. When absent or false, the plugin is optional and the user can choose whether to include it." }, + "onSetupMessage": { + "type": "string", + "description": "Message displayed to the user after project initialization. Use this to inform about manual setup steps (e.g. environment variables, resource provisioning)." + }, "resources": { "type": "object", "required": ["required", "optional"], diff --git a/template/appkit.plugins.json b/template/appkit.plugins.json index f87079ab..7fc8fb6d 100644 --- a/template/appkit.plugins.json +++ b/template/appkit.plugins.json @@ -34,7 +34,8 @@ "resources": { "required": [], "optional": [] - } + }, + "onSetupMessage": "Configure environment variables before running or deploying the app.\nSee: https://databricks.github.io/appkit/docs/plugins/lakebase" }, "server": { "name": "server", From 604ed6cdc69263967fee5e694096a7288a943d5f Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Thu, 26 Feb 2026 09:41:14 +0100 Subject: [PATCH 8/9] chore: address comments --- docs/docs/plugins/analytics.md | 2 -- packages/appkit/src/index.ts | 2 -- 2 files changed, 4 deletions(-) diff --git a/docs/docs/plugins/analytics.md b/docs/docs/plugins/analytics.md index dd44995c..7d8fe69c 100644 --- a/docs/docs/plugins/analytics.md +++ b/docs/docs/plugins/analytics.md @@ -57,9 +57,7 @@ WHERE workspace_id = :workspaceId The analytics plugin exposes these endpoints (mounted under `/api/analytics`): - `POST /api/analytics/query/:query_key` -- `POST /api/analytics/users/me/query/:query_key` - `GET /api/analytics/arrow-result/:jobId` -- `GET /api/analytics/users/me/arrow-result/:jobId` ## Format options diff --git a/packages/appkit/src/index.ts b/packages/appkit/src/index.ts index 9732c0d0..a5e6f50c 100644 --- a/packages/appkit/src/index.ts +++ b/packages/appkit/src/index.ts @@ -48,8 +48,6 @@ export { // Plugin authoring export { Plugin, type ToPlugin, toPlugin } from "./plugin"; export { analytics, lakebase, server } from "./plugins"; -export { LakebasePlugin } from "./plugins/lakebase"; -export { ServerPlugin } from "./plugins/server"; // Registry types and utilities for plugin manifests export type { ConfigSchema, From 4ef9002310012f68183a1728b8ab0edda9963942 Mon Sep 17 00:00:00 2001 From: Pawel Kosiec Date: Thu, 26 Feb 2026 10:07:21 +0100 Subject: [PATCH 9/9] chore: regenerate docs --- docs/docs/api/appkit/Class.LakebasePlugin.md | 571 --------------- docs/docs/api/appkit/Class.Plugin.md | 5 - docs/docs/api/appkit/Class.ServerPlugin.md | 725 ------------------- docs/docs/api/appkit/index.md | 2 - docs/docs/api/appkit/typedoc-sidebar.ts | 10 - 5 files changed, 1313 deletions(-) delete mode 100644 docs/docs/api/appkit/Class.LakebasePlugin.md delete mode 100644 docs/docs/api/appkit/Class.ServerPlugin.md diff --git a/docs/docs/api/appkit/Class.LakebasePlugin.md b/docs/docs/api/appkit/Class.LakebasePlugin.md deleted file mode 100644 index fd612da2..00000000 --- a/docs/docs/api/appkit/Class.LakebasePlugin.md +++ /dev/null @@ -1,571 +0,0 @@ -# Class: LakebasePlugin - -AppKit plugin for Databricks Lakebase Autoscaling. - -Wraps `@databricks/lakebase` to provide a standard `pg.Pool` with automatic -OAuth token refresh, integrated with AppKit's logger and OpenTelemetry setup. - -## Example - -```ts -import { createApp, lakebase, server } from "@databricks/appkit"; - -const AppKit = await createApp({ - plugins: [server(), lakebase()], -}); - -const result = await AppKit.lakebase.query("SELECT * FROM users WHERE id = $1", [userId]); -``` - -## Extends - -- [`Plugin`](Class.Plugin.md) - -## Constructors - -### Constructor - -```ts -new LakebasePlugin(config: ILakebaseConfig): LakebasePlugin; -``` - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `config` | `ILakebaseConfig` | - -#### Returns - -`LakebasePlugin` - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`constructor`](Class.Plugin.md#constructor) - -## Properties - -### app - -```ts -protected app: AppManager; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`app`](Class.Plugin.md#app) - -*** - -### cache - -```ts -protected cache: CacheManager; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`cache`](Class.Plugin.md#cache) - -*** - -### config - -```ts -protected config: ILakebaseConfig; -``` - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`config`](Class.Plugin.md#config) - -*** - -### devFileReader - -```ts -protected devFileReader: DevFileReader; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`devFileReader`](Class.Plugin.md#devfilereader) - -*** - -### isReady - -```ts -protected isReady: boolean = false; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`isReady`](Class.Plugin.md#isready) - -*** - -### name - -```ts -name: string = "lakebase"; -``` - -Plugin name identifier. - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`name`](Class.Plugin.md#name) - -*** - -### streamManager - -```ts -protected streamManager: StreamManager; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`streamManager`](Class.Plugin.md#streammanager) - -*** - -### telemetry - -```ts -protected telemetry: ITelemetry; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`telemetry`](Class.Plugin.md#telemetry) - -*** - -### manifest - -```ts -static manifest: PluginManifest = lakebaseManifest; -``` - -Plugin manifest declaring metadata and resource requirements - -*** - -### phase - -```ts -static phase: PluginPhase = "normal"; -``` - -Plugin initialization phase. -- 'core': Initialized first (e.g., config plugins) -- 'normal': Initialized second (most plugins) -- 'deferred': Initialized last (e.g., server plugin) - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`phase`](Class.Plugin.md#phase) - -## Methods - -### abortActiveOperations() - -```ts -abortActiveOperations(): void; -``` - -Gracefully drains and closes the connection pool. -Called automatically by AppKit during shutdown. - -#### Returns - -`void` - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`abortActiveOperations`](Class.Plugin.md#abortactiveoperations) - -*** - -### asUser() - -```ts -asUser(req: Request): this; -``` - -Execute operations using the user's identity from the request. -Returns a proxy of this plugin where all method calls execute -with the user's Databricks credentials instead of the service principal. - -#### Parameters - -| Parameter | Type | Description | -| ------ | ------ | ------ | -| `req` | `Request` | The Express request containing the user token in headers | - -#### Returns - -`this` - -A proxied plugin instance that executes as the user - -#### Throws - -Error if user token is not available in request headers - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`asUser`](Class.Plugin.md#asuser) - -*** - -### execute() - -```ts -protected execute( - fn: (signal?: AbortSignal) => Promise, - options: PluginExecutionSettings, -userKey?: string): Promise; -``` - -#### Type Parameters - -| Type Parameter | -| ------ | -| `T` | - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `fn` | (`signal?`: `AbortSignal`) => `Promise`\<`T`\> | -| `options` | `PluginExecutionSettings` | -| `userKey?` | `string` | - -#### Returns - -`Promise`\<`T` \| `undefined`\> - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`execute`](Class.Plugin.md#execute) - -*** - -### executeStream() - -```ts -protected executeStream( - res: IAppResponse, - fn: StreamExecuteHandler, - options: StreamExecutionSettings, -userKey?: string): Promise; -``` - -#### Type Parameters - -| Type Parameter | -| ------ | -| `T` | - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `res` | `IAppResponse` | -| `fn` | `StreamExecuteHandler`\<`T`\> | -| `options` | [`StreamExecutionSettings`](Interface.StreamExecutionSettings.md) | -| `userKey?` | `string` | - -#### Returns - -`Promise`\<`void`\> - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`executeStream`](Class.Plugin.md#executestream) - -*** - -### exports() - -```ts -exports(): { - getOrmConfig: () => { - password: string | () => string | () => Promise | undefined; - ssl: | boolean - | { - rejectUnauthorized: boolean | undefined; - }; - username: string | undefined; - }; - getPgConfig: () => PoolConfig; - pool: Pool; - query: (text: string, values?: unknown[]) => Promise>; -}; -``` - -Returns the plugin's public API, accessible via `AppKit.lakebase`. - -- `pool` — The raw `pg.Pool` instance, for use with ORMs or advanced scenarios -- `query` — Convenience method for executing parameterized SQL queries -- `getOrmConfig()` — Returns a config object compatible with Drizzle, TypeORM, Sequelize, etc. -- `getPgConfig()` — Returns a `pg.PoolConfig` object for manual pool construction - -#### Returns - -##### getOrmConfig() - -```ts -getOrmConfig: () => { - password: string | () => string | () => Promise | undefined; - ssl: | boolean - | { - rejectUnauthorized: boolean | undefined; - }; - username: string | undefined; -}; -``` - -###### Returns - -```ts -{ - password: string | () => string | () => Promise | undefined; - ssl: | boolean - | { - rejectUnauthorized: boolean | undefined; - }; - username: string | undefined; -} -``` - -###### password - -```ts -password: string | () => string | () => Promise | undefined; -``` - -###### ssl - -```ts -ssl: - | boolean - | { - rejectUnauthorized: boolean | undefined; -}; -``` - -###### username - -```ts -username: string | undefined = user; -``` - -##### getPgConfig() - -```ts -getPgConfig: () => PoolConfig; -``` - -###### Returns - -`PoolConfig` - -##### pool - -```ts -pool: Pool; -``` - -##### query() - -```ts -query: (text: string, values?: unknown[]) => Promise>; -``` - -Executes a parameterized SQL query against the Lakebase pool. - -###### Type Parameters - -| Type Parameter | Default type | -| ------ | ------ | -| `T` *extends* `QueryResultRow` | `any` | - -###### Parameters - -| Parameter | Type | Description | -| ------ | ------ | ------ | -| `text` | `string` | SQL query string, using `$1`, `$2`, ... placeholders | -| `values?` | `unknown`[] | Parameter values corresponding to placeholders | - -###### Returns - -`Promise`\<`QueryResult`\<`T`\>\> - -Query result with typed rows - -###### Example - -```ts -const result = await AppKit.lakebase.query<{ id: number; name: string }>( - "SELECT id, name FROM users WHERE active = $1", - [true], -); -``` - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`exports`](Class.Plugin.md#exports) - -*** - -### getEndpoints() - -```ts -getEndpoints(): PluginEndpointMap; -``` - -#### Returns - -`PluginEndpointMap` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`getEndpoints`](Class.Plugin.md#getendpoints) - -*** - -### injectRoutes() - -```ts -injectRoutes(_: Router): void; -``` - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `_` | `Router` | - -#### Returns - -`void` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`injectRoutes`](Class.Plugin.md#injectroutes) - -*** - -### query() - -```ts -query(text: string, values?: unknown[]): Promise>; -``` - -Executes a parameterized SQL query against the Lakebase pool. - -#### Type Parameters - -| Type Parameter | Default type | -| ------ | ------ | -| `T` *extends* `QueryResultRow` | `any` | - -#### Parameters - -| Parameter | Type | Description | -| ------ | ------ | ------ | -| `text` | `string` | SQL query string, using `$1`, `$2`, ... placeholders | -| `values?` | `unknown`[] | Parameter values corresponding to placeholders | - -#### Returns - -`Promise`\<`QueryResult`\<`T`\>\> - -Query result with typed rows - -#### Example - -```ts -const result = await AppKit.lakebase.query<{ id: number; name: string }>( - "SELECT id, name FROM users WHERE active = $1", - [true], -); -``` - -*** - -### registerEndpoint() - -```ts -protected registerEndpoint(name: string, path: string): void; -``` - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `name` | `string` | -| `path` | `string` | - -#### Returns - -`void` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`registerEndpoint`](Class.Plugin.md#registerendpoint) - -*** - -### route() - -```ts -protected route<_TResponse>(router: Router, config: RouteConfig): void; -``` - -#### Type Parameters - -| Type Parameter | -| ------ | -| `_TResponse` | - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `router` | `Router` | -| `config` | `RouteConfig` | - -#### Returns - -`void` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`route`](Class.Plugin.md#route) - -*** - -### setup() - -```ts -setup(): Promise; -``` - -Initializes the Lakebase connection pool. -Called automatically by AppKit during the plugin setup phase. - -Resolves the PostgreSQL username via [getUsernameWithApiLookup](Function.getUsernameWithApiLookup.md), -which tries config, env vars, and finally the Databricks workspace API. - -#### Returns - -`Promise`\<`void`\> - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`setup`](Class.Plugin.md#setup) diff --git a/docs/docs/api/appkit/Class.Plugin.md b/docs/docs/api/appkit/Class.Plugin.md index 4c1f0403..64de5830 100644 --- a/docs/docs/api/appkit/Class.Plugin.md +++ b/docs/docs/api/appkit/Class.Plugin.md @@ -84,11 +84,6 @@ class MyPlugin extends Plugin { } ``` -## Extended by - -- [`LakebasePlugin`](Class.LakebasePlugin.md) -- [`ServerPlugin`](Class.ServerPlugin.md) - ## Type Parameters | Type Parameter | Default type | diff --git a/docs/docs/api/appkit/Class.ServerPlugin.md b/docs/docs/api/appkit/Class.ServerPlugin.md deleted file mode 100644 index 4058343d..00000000 --- a/docs/docs/api/appkit/Class.ServerPlugin.md +++ /dev/null @@ -1,725 +0,0 @@ -# Class: ServerPlugin - -Server plugin for the AppKit. - -This plugin is responsible for starting the server and serving the static files. -It also handles the remote tunneling for development purposes. - -## Example - -```ts -createApp({ - plugins: [server(), telemetryExamples(), analytics({})], -}); -``` - -## Extends - -- [`Plugin`](Class.Plugin.md) - -## Constructors - -### Constructor - -```ts -new ServerPlugin(config: ServerConfig): ServerPlugin; -``` - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `config` | `ServerConfig` | - -#### Returns - -`ServerPlugin` - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`constructor`](Class.Plugin.md#constructor) - -## Properties - -### app - -```ts -protected app: AppManager; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`app`](Class.Plugin.md#app) - -*** - -### cache - -```ts -protected cache: CacheManager; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`cache`](Class.Plugin.md#cache) - -*** - -### config - -```ts -protected config: ServerConfig; -``` - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`config`](Class.Plugin.md#config) - -*** - -### devFileReader - -```ts -protected devFileReader: DevFileReader; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`devFileReader`](Class.Plugin.md#devfilereader) - -*** - -### isReady - -```ts -protected isReady: boolean = false; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`isReady`](Class.Plugin.md#isready) - -*** - -### name - -```ts -name: "server"; -``` - -Plugin name identifier. - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`name`](Class.Plugin.md#name) - -*** - -### streamManager - -```ts -protected streamManager: StreamManager; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`streamManager`](Class.Plugin.md#streammanager) - -*** - -### telemetry - -```ts -protected telemetry: ITelemetry; -``` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`telemetry`](Class.Plugin.md#telemetry) - -*** - -### DEFAULT\_CONFIG - -```ts -static DEFAULT_CONFIG: { - autoStart: boolean; - host: string; - port: number; -}; -``` - -#### autoStart - -```ts -autoStart: boolean = true; -``` - -#### host - -```ts -host: string; -``` - -#### port - -```ts -port: number; -``` - -*** - -### manifest - -```ts -static manifest: PluginManifest = serverManifest; -``` - -Plugin manifest declaring metadata and resource requirements - -*** - -### phase - -```ts -static phase: PluginPhase = "deferred"; -``` - -Plugin initialization phase. -- 'core': Initialized first (e.g., config plugins) -- 'normal': Initialized second (most plugins) -- 'deferred': Initialized last (e.g., server plugin) - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`phase`](Class.Plugin.md#phase) - -## Methods - -### abortActiveOperations() - -```ts -abortActiveOperations(): void; -``` - -#### Returns - -`void` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`abortActiveOperations`](Class.Plugin.md#abortactiveoperations) - -*** - -### asUser() - -```ts -asUser(req: Request): this; -``` - -Execute operations using the user's identity from the request. -Returns a proxy of this plugin where all method calls execute -with the user's Databricks credentials instead of the service principal. - -#### Parameters - -| Parameter | Type | Description | -| ------ | ------ | ------ | -| `req` | `Request` | The Express request containing the user token in headers | - -#### Returns - -`this` - -A proxied plugin instance that executes as the user - -#### Throws - -Error if user token is not available in request headers - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`asUser`](Class.Plugin.md#asuser) - -*** - -### execute() - -```ts -protected execute( - fn: (signal?: AbortSignal) => Promise, - options: PluginExecutionSettings, -userKey?: string): Promise; -``` - -#### Type Parameters - -| Type Parameter | -| ------ | -| `T` | - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `fn` | (`signal?`: `AbortSignal`) => `Promise`\<`T`\> | -| `options` | `PluginExecutionSettings` | -| `userKey?` | `string` | - -#### Returns - -`Promise`\<`T` \| `undefined`\> - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`execute`](Class.Plugin.md#execute) - -*** - -### executeStream() - -```ts -protected executeStream( - res: IAppResponse, - fn: StreamExecuteHandler, - options: StreamExecutionSettings, -userKey?: string): Promise; -``` - -#### Type Parameters - -| Type Parameter | -| ------ | -| `T` | - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `res` | `IAppResponse` | -| `fn` | `StreamExecuteHandler`\<`T`\> | -| `options` | [`StreamExecutionSettings`](Interface.StreamExecutionSettings.md) | -| `userKey?` | `string` | - -#### Returns - -`Promise`\<`void`\> - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`executeStream`](Class.Plugin.md#executestream) - -*** - -### exports() - -```ts -exports(): { - getConfig: () => { - [key: string]: unknown; - autoStart?: boolean; - host?: string; - name?: string; - port?: number; - staticPath?: string; - telemetry?: TelemetryOptions; - }; - getServer: () => Server; - start: () => Promise; - extend: { start: () => Promise; extend(fn: (app: Application) => void): ...; getServer: () => Server; getConfig: () => { ...; }; }; -}; -``` - -Returns the public exports for the server plugin. -Exposes server management methods. - -#### Returns - -##### getConfig() - -```ts -getConfig: () => { -[key: string]: unknown; - autoStart?: boolean; - host?: string; - name?: string; - port?: number; - staticPath?: string; - telemetry?: TelemetryOptions; -}; -``` - -Get the server configuration - -Get the server configuration. - -###### Returns - -```ts -{ -[key: string]: unknown; - autoStart?: boolean; - host?: string; - name?: string; - port?: number; - staticPath?: string; - telemetry?: TelemetryOptions; -} -``` - -###### autoStart? - -```ts -optional autoStart: boolean; -``` - -###### host? - -```ts -optional host: string; -``` - -###### name? - -```ts -optional name: string; -``` - -###### port? - -```ts -optional port: number; -``` - -###### staticPath? - -```ts -optional staticPath: string; -``` - -###### telemetry? - -```ts -optional telemetry: TelemetryOptions; -``` - -##### getServer() - -```ts -getServer: () => Server; -``` - -Get the underlying HTTP server instance - -Get the low level node.js http server instance. - -Only use this method if you need to access the server instance for advanced usage like a custom websocket server, etc. - -###### Returns - -`Server` - -The server instance. - -###### Throws - -If the server is not started or autoStart is true. - -##### start() - -```ts -start: () => Promise; -``` - -Start the server - -Start the server. - -This method starts the server and sets up the frontend. -It also sets up the remote tunneling if enabled. - -###### Returns - -`Promise`\<`Application`\> - -The express application. - -##### extend() - -```ts -extend(fn: (app: Application) => void): { start: () => Promise; extend(fn: (app: Application) => void): ...; getServer: () => Server; getConfig: () => { ...; }; }; -``` - -Extend the server with custom routes or middleware - -###### Parameters - -| Parameter | Type | -| ------ | ------ | -| `fn` | (`app`: `Application`) => `void` | - -###### Returns - -\{ start: () =\> Promise\; extend(fn: (app: Application) =\> void): ...; getServer: () =\> Server\; getConfig: () =\> \{ ...; \}; \} - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`exports`](Class.Plugin.md#exports) - -*** - -### extend() - -```ts -extend(fn: (app: Application) => void): ServerPlugin; -``` - -Extend the server with custom routes or middleware. - -#### Parameters - -| Parameter | Type | Description | -| ------ | ------ | ------ | -| `fn` | (`app`: `Application`) => `void` | A function that receives the express application. | - -#### Returns - -`ServerPlugin` - -The server plugin instance for chaining. - -#### Throws - -If autoStart is true. - -*** - -### getConfig() - -```ts -getConfig(): { -[key: string]: unknown; - autoStart?: boolean; - host?: string; - name?: string; - port?: number; - staticPath?: string; - telemetry?: TelemetryOptions; -}; -``` - -Get the server configuration. - -#### Returns - -```ts -{ -[key: string]: unknown; - autoStart?: boolean; - host?: string; - name?: string; - port?: number; - staticPath?: string; - telemetry?: TelemetryOptions; -} -``` - -##### autoStart? - -```ts -optional autoStart: boolean; -``` - -##### host? - -```ts -optional host: string; -``` - -##### name? - -```ts -optional name: string; -``` - -##### port? - -```ts -optional port: number; -``` - -##### staticPath? - -```ts -optional staticPath: string; -``` - -##### telemetry? - -```ts -optional telemetry: TelemetryOptions; -``` - -*** - -### getEndpoints() - -```ts -getEndpoints(): PluginEndpointMap; -``` - -#### Returns - -`PluginEndpointMap` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`getEndpoints`](Class.Plugin.md#getendpoints) - -*** - -### getServer() - -```ts -getServer(): Server; -``` - -Get the low level node.js http server instance. - -Only use this method if you need to access the server instance for advanced usage like a custom websocket server, etc. - -#### Returns - -`Server` - -The server instance. - -#### Throws - -If the server is not started or autoStart is true. - -*** - -### injectRoutes() - -```ts -injectRoutes(_: Router): void; -``` - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `_` | `Router` | - -#### Returns - -`void` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`injectRoutes`](Class.Plugin.md#injectroutes) - -*** - -### registerEndpoint() - -```ts -protected registerEndpoint(name: string, path: string): void; -``` - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `name` | `string` | -| `path` | `string` | - -#### Returns - -`void` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`registerEndpoint`](Class.Plugin.md#registerendpoint) - -*** - -### route() - -```ts -protected route<_TResponse>(router: Router, config: RouteConfig): void; -``` - -#### Type Parameters - -| Type Parameter | -| ------ | -| `_TResponse` | - -#### Parameters - -| Parameter | Type | -| ------ | ------ | -| `router` | `Router` | -| `config` | `RouteConfig` | - -#### Returns - -`void` - -#### Inherited from - -[`Plugin`](Class.Plugin.md).[`route`](Class.Plugin.md#route) - -*** - -### setup() - -```ts -setup(): Promise; -``` - -Setup the server plugin. - -#### Returns - -`Promise`\<`void`\> - -#### Overrides - -[`Plugin`](Class.Plugin.md).[`setup`](Class.Plugin.md#setup) - -*** - -### shouldAutoStart() - -```ts -shouldAutoStart(): boolean | undefined; -``` - -Check if the server should auto start. - -#### Returns - -`boolean` \| `undefined` - -*** - -### start() - -```ts -start(): Promise; -``` - -Start the server. - -This method starts the server and sets up the frontend. -It also sets up the remote tunneling if enabled. - -#### Returns - -`Promise`\<`Application`\> - -The express application. diff --git a/docs/docs/api/appkit/index.md b/docs/docs/api/appkit/index.md index 98d18ea4..2bd9ad71 100644 --- a/docs/docs/api/appkit/index.md +++ b/docs/docs/api/appkit/index.md @@ -20,11 +20,9 @@ plugin architecture, and React integration. | [ConnectionError](Class.ConnectionError.md) | Error thrown when a connection or network operation fails. Use for database pool errors, API failures, timeouts, etc. | | [ExecutionError](Class.ExecutionError.md) | Error thrown when an operation execution fails. Use for statement failures, canceled operations, or unexpected states. | | [InitializationError](Class.InitializationError.md) | Error thrown when a service or component is not properly initialized. Use when accessing services before they are ready. | -| [LakebasePlugin](Class.LakebasePlugin.md) | AppKit plugin for Databricks Lakebase Autoscaling. | | [Plugin](Class.Plugin.md) | Base abstract class for creating AppKit plugins. | | [ResourceRegistry](Class.ResourceRegistry.md) | Central registry for tracking plugin resource requirements. Deduplication uses type + resourceKey (machine-stable); alias is for display only. | | [ServerError](Class.ServerError.md) | Error thrown when server lifecycle operations fail. Use for server start/stop issues, configuration conflicts, etc. | -| [ServerPlugin](Class.ServerPlugin.md) | Server plugin for the AppKit. | | [TunnelError](Class.TunnelError.md) | Error thrown when remote tunnel operations fail. Use for tunnel connection issues, message parsing failures, etc. | | [ValidationError](Class.ValidationError.md) | Error thrown when input validation fails. Use for invalid parameters, missing required fields, or type mismatches. | diff --git a/docs/docs/api/appkit/typedoc-sidebar.ts b/docs/docs/api/appkit/typedoc-sidebar.ts index 5329fd1b..21df87aa 100644 --- a/docs/docs/api/appkit/typedoc-sidebar.ts +++ b/docs/docs/api/appkit/typedoc-sidebar.ts @@ -51,11 +51,6 @@ const typedocSidebar: SidebarsConfig = { id: "api/appkit/Class.InitializationError", label: "InitializationError" }, - { - type: "doc", - id: "api/appkit/Class.LakebasePlugin", - label: "LakebasePlugin" - }, { type: "doc", id: "api/appkit/Class.Plugin", @@ -71,11 +66,6 @@ const typedocSidebar: SidebarsConfig = { id: "api/appkit/Class.ServerError", label: "ServerError" }, - { - type: "doc", - id: "api/appkit/Class.ServerPlugin", - label: "ServerPlugin" - }, { type: "doc", id: "api/appkit/Class.TunnelError",