Skip to content

Class: LakebaseAiSearchPlugin

Lakebase implementation of the native AppKit aiSearch contract.

new LakebaseAiSearchPlugin(config): LakebaseAiSearchPlugin

LakebaseAiSearchConfig

LakebaseAiSearchPlugin

Plugin<LakebaseAiSearchConfig>.constructor

protected app: AppManager

SearchPlugin.app


protected cache: CacheManager

SearchPlugin.cache


protected config: LakebaseAiSearchConfig

Plugin.config


protected optional context?: PluginContext

SearchPlugin.context


protected devFileReader: DevFileReader

SearchPlugin.devFileReader


protected isReady: boolean

SearchPlugin.isReady


name: string

Plugin name identifier.

SearchPlugin.name


protected streamManager: StreamManager

SearchPlugin.streamManager


protected telemetry: ITelemetry

SearchPlugin.telemetry


static manifest: object

config: object

schema: JSONSchema7 = CONFIG_SCHEMA

description: string = "AppKit AI Search contract backed by PostgreSQL full-text search"

displayName: string = "Lakebase AI Search"

name: "aiSearch" = "aiSearch"

resources: object

optional: never[] = []

required: never[] = []

stability: "beta" = "beta"


static phase: PluginPhase

Plugin initialization phase.

  • ‘core’: Initialized first (e.g., config plugins)
  • ‘normal’: Initialized second (most plugins)
  • ‘deferred’: Initialized last (e.g., server plugin)

Plugin.phase

abortActiveOperations(): void

Cancel in-flight work (abort signals, SSE streams). Runs in the first phase of graceful shutdown, BEFORE any plugin’s shutdown() hook — so it must not tear down shared resources (e.g. connection pools) that other plugins’ hooks may still need. Put teardown in shutdown().

void

Plugin.abortActiveOperations


addDocuments(alias, documents): Promise<{ count: number; index: string; }>

Add or update documents in one configured Lakebase full-text index.

string

Record<string, unknown>[]

Promise<{ count: number; index: string; }>


asUser(req): 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.

Request

The Express request containing the user token in headers

this

A proxied plugin instance that executes as the user

AuthenticationError if user token is not available in request headers (production only). In development mode (NODE_ENV=development), skips user impersonation instead of throwing.

Plugin.asUser


attachContext(deps?): void

Binds runtime dependencies (telemetry provider, cache, plugin context) to this plugin. Called by AppKit._createApp after construction and before setup(). Idempotent: safe to call if the constructor already bound them eagerly. Kept separate so factories can eagerly construct plugin instances without running this before TelemetryManager.initialize() / CacheManager.getInstance() have run.

unknown

TelemetryOptions

void

Plugin.attachContext


clientConfig(): object

Returns startup config to expose to the client. Override this to surface server-side values that are safe to publish to the frontend, such as feature flags, resource IDs, or other app boot settings.

This runs once when the server starts, so it should not depend on request-scoped or user-specific state.

String values that match non-public environment variables are redacted unless you intentionally expose them via a matching PUBLIC_APPKIT_ env var.

Values must be JSON-serializable plain data (no functions, Dates, classes, Maps, Sets, BigInts, or circular references). By default returns an empty object (plugin contributes nothing to client config).

On the client, read the config with the usePluginClientConfig hook (React) or the getPluginClientConfig function (vanilla JS), both from @databricks/appkit-ui.

object

indexes: object[]

// Server — plugin definition
class MyPlugin extends Plugin<MyConfig> {
clientConfig() {
return {
warehouseId: this.config.warehouseId,
features: { darkMode: true },
};
}
}
// Client — React component
import { usePluginClientConfig } from "@databricks/appkit-ui/react";
interface MyPluginConfig { warehouseId: string; features: { darkMode: boolean } }
const config = usePluginClientConfig<MyPluginConfig>("myPlugin");
config.warehouseId; // "abc-123"
// Client — vanilla JS
import { getPluginClientConfig } from "@databricks/appkit-ui/js";
const config = getPluginClientConfig<MyPluginConfig>("myPlugin");

Plugin.clientConfig


protected execute<T>(fn, options, userKey?): Promise<ExecutionResult<T>>

Execute a function with the plugin’s interceptor chain.

Returns an ExecutionResult discriminated union:

  • { ok: true, data: T } on success
  • { ok: false, status: number, message: string } on failure

Errors are never thrown — the method is production-safe.

T

(signal?) => Promise<T>

PluginExecutionSettings

string

Promise<ExecutionResult<T>>

Plugin.execute


protected executeStream<T>(res, fn, options, userKey?): Promise<void>

T

IAppResponse

StreamExecuteHandler<T>

StreamExecutionSettings

string

Promise<void>

Plugin.executeStream


exports(): object

Returns the public exports for this plugin. Override this to define a custom public API. By default, returns an empty object.

The returned object becomes the plugin’s public API on the AppKit instance (e.g. appkit.myPlugin.method()). AppKit automatically binds method context and adds asUser(req) for user-scoped execution.

addDocuments: (alias, documents) => Promise<{ count: number; index: string; }>

Add or update documents in one configured Lakebase full-text index.

string

Record<string, unknown>[]

Promise<{ count: number; index: string; }>

providerKind: "lakebase"

query: (alias, request) => Promise<SearchResponse<Record<string, unknown>>>

Query one configured Lakebase full-text index using AppKit’s response shape.

string

SearchRequest

Promise<SearchResponse<Record<string, unknown>>>

class MyPlugin extends Plugin {
private getData() { return []; }
exports() {
return { getData: this.getData };
}
}
// After registration:
const appkit = await createApp({ plugins: [myPlugin()] });
appkit.myPlugin.getData();

Plugin.exports


getEndpoints(): PluginEndpointMap

PluginEndpointMap

Plugin.getEndpoints


getSkipBodyParsingPaths(): ReadonlySet<string>

ReadonlySet<string>

Plugin.getSkipBodyParsingPaths


injectRoutes(router): void

Router

void

Plugin.injectRoutes


query(alias, request): Promise<SearchResponse<Record<string, unknown>>>

Query one configured Lakebase full-text index using AppKit’s response shape.

string

SearchRequest

Promise<SearchResponse<Record<string, unknown>>>


protected registerEndpoint(name, path): void

string

string

void

Plugin.registerEndpoint


protected resolveUserId(req): string

Resolve the effective user ID from a request.

Returns the x-forwarded-user header when present. In development mode (NODE_ENV=development) falls back to the current context user ID so that callers outside an active runInUserContext scope still get a consistent value.

Request

string

AuthenticationError in production when no user header is present.

Plugin.resolveUserId


protected route<_TResponse>(router, config): void

_TResponse

Router

RouteConfig

void

Plugin.route


setup(): Promise<void>

Promise<void>

Plugin.setup


shutdown(): Promise<void>

Promise<void>