@brickkit/core

@brickkit/core exports 176 names: 63 functions, 8 classes, 68 interfaces, 34 types, 3 variables. It also re-exports 4 from @sinclair/typebox and 33 from drizzle-orm.

import { ACTION_ACCESS_KEY, ActionExecutionError, attachDatabase } from "@brickkit/core";

FunctionsCopy Anchor Link

attachDatabaseCopy Anchor Link

function attachDatabase<TDb>(
  service: Service<TDb, any>,
  database: DatabaseHandle<TDb>,
): TDb

Attach a defined database. Schema changes remain the caller's responsibility.

Parameters

Returns TDb

Source: packages/core/src/db/index.ts:93

bindCompiledApplicationCopy Anchor Link

function bindCompiledApplication(
  ir: BrickIR,
  services: Service<any, any>[],
  factories: readonly HandlerFactory[],
): CompiledApplication

Build artifact binder: consumes emitted functions, with no runtime handler code generation.

Parameters

Returns CompiledApplication

Source: packages/core/src/compiler.ts:103

brickCopy Anchor Link

function brick(options: CreateServerOptions = {}): BrickApp

Create the HTTP application: an Elysia app that serves every service's actions (and the tools that opt in with http: true) as routes, with /_health, an OpenAPI document at /openapi.json, Scalar at /docs, Swagger UI at /swagger, and the shape of the services at /_brick/services.

Services come from the global registry unless services is given. The app does not listen by itself: export it from your entry file, where brick dev, brick start, and the Vite plugin load it, or call app.listen(port) in your own server bootstrap.

Parameters

Returns BrickApp — The app, with definition (its services, prefix, and routes), endpoint() to add raw routes, and listEndpoints() to list them.

Throws

• When a required secret is missing, or documentation or dashboard is invalid.

Example

import { brick } from "@brickkit/core";
import { pagesService } from "./services/pages";

export default brick({
  services: [pagesService],
  title: "Pages API",
  telemetry: true,
});

Source: packages/core/src/server.ts:115

buildErrorHelpersCopy Anchor Link

function buildErrorHelpers<
  TErrors extends Record<string, ActionErrorDefinition>,
>(
  errorsDef?: TErrors,
): ErrorBuilder<TErrors>

The error helpers an action receives: one function per error code that throws an ActionExecutionError with that code and status. The standard HTTP codes (BAD_REQUEST, UNAUTHORIZED, FORBIDDEN, NOT_FOUND, CONFLICT, INTERNAL_SERVER_ERROR) are always there; the action's own errors add to them or replace one.

Parameters

Returns ErrorBuilder<TErrors> — Helpers that take an optional message, details, and ErrorOptions, and always throw.

Source: packages/core/src/action.ts:70

buildFtsMatchQueryCopy Anchor Link

function buildFtsMatchQuery(search: string): string | null

Builds an FTS5 MATCH condition for a resource search term. Returns null when the term has no usable tokens or FTS errors. Caller falls back to LIKE in that case.

Parameters

Returns string \| null

Source: packages/core/src/db/index.ts:342

compileBrickApplicationCopy Anchor Link

function compileBrickApplication(
  options: { services: Service<any, any>[]; prefix?: string; mode?: "specialized" | "generic"; },
): CompiledApplication

Startup compiler: analyzes once, then binds live callbacks.

Parameters

Returns CompiledApplication

Source: packages/core/src/compiler.ts:79

compileRoutePlanCopy Anchor Link

function compileRoutePlan(
  service: Service,
  action: Action,
  routePath: string,
  method?: string,
): CompiledRoutePlan

Work out, once at startup, everything an action's route needs to answer a request: where its input comes from (body, query, or path), the validators, the authorization and execute functions, and its logger. Low level: brick() does this for every route.

Parameters

Returns CompiledRoutePlan — The plan executeCompiledRoute runs.

Source: packages/core/src/action-handler.ts:38

createActionHandlerCopy Anchor Link

function createActionHandler(
  service: Service,
  action: Action,
  routePath: string,
  method?: string,
): (elysiaCtx: any) => Promise<any>

An Elysia handler for one action: compileRoutePlan and executeCompiledRoute together. Use it to mount an action on your own Elysia app; brick() does it for you.

Parameters

Returns (elysiaCtx: any) => Promise<any> — A function from the Elysia context to the response.

Source: packages/core/src/action-handler.ts:324

createBrickClientCopy Anchor Link

function createBrickClient<TApp extends Record<string, any>>(
  options: BrickClientOptions & { contract: TApp },
): BrickClient<TApp>

function createBrickClient<TApp extends Record<string, any>>(
  options: BrickClientOptions,
): BrickClient<TApp>

Create an Eden/tRPC-style typed client for the application contract TApp. TApp is a type-only parameter: import type { AppServer } keeps backend implementations out of the frontend bundle.

Parameters

Returns BrickClient<TApp>

Source: packages/core/src/client.ts:572

createDatabaseCopy Anchor Link

function createDatabase<
  TSchema extends Record<string, unknown> = Record<string, unknown>,
>(
  config: DatabaseConfig<TSchema> = {},
): BunSQLiteDatabase<TSchema> | PostgresDatabase<TSchema>

Creates a database instance based on the provided configuration. Zero-config: calling createDatabase() returns an ultra-fast Bun-native SQLite database in :memory: mode wrapped with Drizzle ORM.

Parameters

Returns BunSQLiteDatabase<TSchema> \| PostgresDatabase<TSchema>

Source: packages/core/src/db/index.ts:70

createEndpointHandlerCopy Anchor Link

function createEndpointHandler(
  def: EndpointDefinition,
  services: Service<any, any>[],
): (elysiaCtx: any) => Promise<unknown>

Wrap a raw handler with trace ids, logger, db, and mesh-consistent error mapping.

Parameters

Returns (elysiaCtx: any) => Promise<unknown>

Source: packages/core/src/endpoints.ts:71

createMcpHandlerCopy Anchor Link

function createMcpHandler(
  options: McpHandlerOptions,
): (request: Request, ctx?: Partial<ActionContext>) => Promise<Response>

Stateless MCP JSON-RPC POST handler. Wrap with the app's authentication.

Parameters

Returns (request: Request, ctx?: Partial<ActionContext>) => Promise<Response>

Source: packages/core/src/mcp.ts:89

createMcpRegistryCopy Anchor Link

function createMcpRegistry(options: McpRegistryOptions): McpRegistry

Collect only explicitly defined tools, without exposing ordinary actions.

Parameters

Returns McpRegistry

Source: packages/core/src/mcp.ts:33

createPostgresDatabaseCopy Anchor Link

function createPostgresDatabase<
  TSchema extends Record<string, unknown> = Record<string, unknown>,
>(
  config: PostgresDatabaseConfig<TSchema> = {},
): PostgresDatabase<TSchema>

Creates a PostgreSQL Drizzle instance using postgres-js. Static imports (both are hard dependencies in package.json) so bundlers (Nitro/Rollup) trace and ship the driver. bun:sqlite stays lazy in sqlite.ts since it only exists under Bun.

Parameters

Returns PostgresDatabase<TSchema>

Source: packages/core/src/db/postgres.ts:46

createServiceProxyCopy Anchor Link

function createServiceProxy<T extends Record<string, any>>(
  serviceName: string,
  options: ProxyOptions = {},
): T

A typed way to call another service's actions in-process. Each property of the proxy is an action of that service: call it with the action's input, and optionally a call context.

The call runs through the target's own validation and authorization, with the target's database and context (never the caller's), and shows as an rpc span in the trace. Only in-process dispatch exists: with isMonolith: false a call throws. Use the typed client to call a service over HTTP.

Parameters

Returns T — A proxy typed as T, usually the target's actions.

Throws

• On a call, when the service or the action is not registered.

Example

import { createServiceProxy } from "@brickkit/core";

const pages = createServiceProxy<{ get(input: { id: string }): Promise<Page> }>(
  "pages",
  { from: "billing" },
);
const page = await pages.get({ id: "p_1" });

Source: packages/core/src/rpc.ts:31

createSQLiteDatabaseCopy Anchor Link

function createSQLiteDatabase<
  TSchema extends Record<string, unknown> = Record<string, unknown>,
>(
  config: SQLiteDatabaseConfig<TSchema> = {},
): BunSQLiteDatabase<TSchema>

Creates a zero-config SQLite database using Bun's native bun:sqlite engine and Drizzle ORM. Defaults to an ultra-fast in-memory database (:memory:).

Bun-only: the driver is loaded lazily so importing @brickkit/core on other runtimes (e.g. Node) stays safe until this function is actually called.

Parameters

Returns BunSQLiteDatabase<TSchema>

Source: packages/core/src/db/sqlite.ts:53

defineActionCopy Anchor Link

function defineAction<
  TInputSchema extends TSchema | undefined = undefined,
  TOutputSchema extends TSchema | undefined = undefined,
  TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>,
  TContext extends ActionContext = ActionContext,
>(
  config: ActionConfigWithAuthorize<TInputSchema, TOutputSchema, TErrors, TContext>,
): Action<TInputSchema, TOutputSchema, TErrors, TContext>

function defineAction<
  TInputSchema extends TSchema | undefined = undefined,
  TOutputSchema extends TSchema | undefined = undefined,
  TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>,
  TContext extends ActionContext = ActionContext,
>(
  config: ActionConfigWithoutAuthorize<TInputSchema, TOutputSchema, TErrors, TContext>,
): Action<TInputSchema, TOutputSchema, TErrors, TContext>

Define an action: a typed, validated function that Brick serves over HTTP, runs in-process, and exposes to the typed client and OpenAPI.

A call runs in order: the input is validated against input (an invalid one is a VALIDATION_FAILED error, HTTP 400); authorize runs, if there is one; execute runs; and its result is validated against output (a mismatch is a server error, HTTP 500). Throw error.CODE(...) from execute for a declared failure or a standard one such as error.NOT_FOUND(). Any other thrown value becomes INTERNAL_SERVER_ERROR (500), with the cause kept out of the response and in the log.

authorize returns false to refuse: the call fails with UNAUTHORIZED (401) when there is no ctx.user, and FORBIDDEN (403) when there is one. Where it is given, execute can rely on what it checked.

Parameters

Returns Action<TInputSchema, TOutputSchema, TErrors, TContext> — The action. Register it with service.action(action); call it directly with action.run(input, ctx).

Example

import { defineAction, t } from "@brickkit/core";

export const getPage = defineAction({
  name: "get",
  method: "GET",
  input: t.Object({ id: t.String() }),
  output: t.Object({ id: t.String(), title: t.String() }),
  errors: { PAGE_GONE: { message: "That page was removed", status: 410 } },
  authorize: ({ user }) => user != null,
  execute: async ({ input, ctx, error }) => {
    const page = await findPage(ctx.db, input.id);
    if (!page) throw error.NOT_FOUND("No such page");
    return page;
  },
});

Source: packages/core/src/action.ts:144

defineDatabaseCopy Anchor Link

function defineDatabase<
  TSchema extends Record<string, unknown> = Record<string, unknown>,
>(
  options?: SQLiteDefinition<TSchema>,
): DatabaseHandle<BunSQLiteDatabase<TSchema>, TSchema>

function defineDatabase<
  TSchema extends Record<string, unknown> = Record<string, unknown>,
>(
  options: PostgresDefinition<TSchema>,
): DatabaseHandle<PostgresJsDatabase<TSchema> & { $client: Sql }, TSchema>

Declare a service's database: its engine, its Drizzle tables, and how to reach it. Nothing connects until the handle is used (getDb()), so defining one has no side effects.

SQLite is the default and needs no options. Pass engine: "postgres" with a url for Postgres. Options that belong to the other engine (such as url for SQLite, or path for Postgres) are refused.

Parameters

Returns DatabaseHandle<BunSQLiteDatabase<TSchema>, TSchema> — A handle to give to defineService({ database }). getDb() returns the Drizzle database.

Throws

• When the engine is unsupported, or an option does not suit the engine.

Example

import { defineDatabase } from "@brickkit/core";
import { sqliteTable, text } from "drizzle-orm/sqlite-core";

const pages = sqliteTable("pages", {
  id: text("id").primaryKey(),
  title: text("title").notNull(),
});

export const database = defineDatabase({ tables: { pages } });

Source: packages/core/src/db/define.ts:109

defineResourceCopy Anchor Link

function defineResource<
  TTable = any,
  TCtx extends ActionContext = ActionContext,
  const O extends ResourceTypeOptions = ResourceTypeOptions,
>(
  service: Service<any, any>,
  config: ResourceConfig<TTable, TCtx> & O,
): Resource<TTable, TCtx, ResourceIdentity<TTable, O>>

Declares a plugin host without registering actions or changing the schema.

Parameters

Returns Resource<TTable, TCtx, ResourceIdentity<TTable, O>>

Source: packages/core/src/resource.ts:13

defineResourcePluginCopy Anchor Link

function defineResourcePlugin<
  S extends Service<any, any> = Service<any, any>,
  R extends Resource<any, any, any> = Resource<any, ContextOf<S>, any>,
  A extends object = object,
>(
  definition: Omit<ResourcePlugin<S, R, A>, typeof pluginKind> & { setup: (context: ResourcePluginContext<S, R>,) => A & (A extends PromiseLike<unknown> ? never …,
): ResourcePlugin<S, R, A>

Define a plugin that installs onto a resource (a table and its entity) with resource.use(plugin). Its setup receives the service, the resource, and a routes registrar, whose routes are scoped under the resource's name, and returns the typed API that resource.use hands back. crud is built this way.

Parameters

Returns ResourcePlugin<S, R, A> — The plugin descriptor, frozen.

Throws

• When the name is empty or has surrounding whitespace.

Source: packages/core/src/plugin.ts:191

defineServiceCopy Anchor Link

function defineService<
  TDb = BunSQLiteDatabase<Record<string, unknown>>,
  TServiceContext extends Record<string, any> = Record<string, any>,
>(
  name: string,
  options?: ServiceOptions<TServiceContext, TDb>,
): Service<TDb, TServiceContext>

Declare a service: a named group of actions, tools, and resources with its own database and request context. It is registered globally, so brick(), the OpenAPI generator, and createServiceProxy find it by name.

Add actions with service.action(...), tools with service.tool(...), resources with service.resource(...), and plugins with service.use(...).

Parameters

Returns Service<TDb, TServiceContext> — The service.

Example

import { defineDatabase, defineService, t } from "@brickkit/core";

const database = defineDatabase({ tables: { pages } });

export const pagesService = defineService("pages", {
  database,
  // Added to `ctx` in every action of this service.
  context: async ({ request }) => ({ user: await readUser(request) }),
});

pagesService.action({
  name: "list",
  input: t.Object({ limit: t.Optional(t.Number()) }),
  output: t.Array(t.Object({ id: t.String(), title: t.String() })),
  execute: ({ input, ctx }) =>
    ctx.db.select().from(pages).limit(input.limit ?? 20),
});

Source: packages/core/src/service.ts:450

defineServicePluginCopy Anchor Link

function defineServicePlugin<
  S extends Service<any, any> = Service<any, any>,
  A = unknown,
>(
  definition: Omit<ServicePlugin<S, A>, typeof pluginKind> & { setup: (context: ServicePluginContext<S>,) => A & (A extends PromiseLike<unknown> ? never : unknow…,
): ServicePlugin<S, A>

Define a plugin that installs onto a service with service.use(plugin). Its setup receives the service and a routes registrar for adding actions and raw HTTP endpoints, and returns the typed API that service.use hands back.

Parameters

Returns ServicePlugin<S, A> — The plugin descriptor, frozen.

Throws

• When the name is empty or has surrounding whitespace.

Example

import { defineServicePlugin, t } from "@brickkit/core";

export const greeting = (salutation = "Hello") =>
  defineServicePlugin({
    name: "example/greeting",
    setup({ routes }) {
      const hello = routes.action({
        name: "hello",
        input: t.Object({ name: t.String() }),
        output: t.String(),
        execute: ({ input }) => `${salutation}, ${input.name}!`,
      });
      return { hello };
    },
  });

const api = greeterService.use(greeting("Welcome"));
await api.hello({ input: { name: "Ada" } });

Source: packages/core/src/plugin.ts:163

defineToolCopy Anchor Link

function defineTool<
  TInputSchema extends TSchema | undefined = undefined,
  TOutputSchema extends TSchema | undefined = undefined,
  TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>,
  TContext extends ActionContext = ActionContext,
>(
  config: ToolConfigWithAuthorize<TInputSchema, TOutputSchema, TErrors, TContext>,
): Tool<TInputSchema, TOutputSchema, TErrors, TContext>

function defineTool<
  TInputSchema extends TSchema | undefined = undefined,
  TOutputSchema extends TSchema | undefined = undefined,
  TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>,
  TContext extends ActionContext = ActionContext,
>(
  config: ToolConfigWithoutAuthorize<TInputSchema, TOutputSchema, TErrors, TContext>,
): Tool<TInputSchema, TOutputSchema, TErrors, TContext>

Define a tool: an action that AI agents can call through MCP. It takes the same configuration as defineAction (validation, authorize, errors), plus title, annotations (the MCP hints about what the tool does), and http to also serve it over HTTP and in OpenAPI (off by default).

Parameters

Returns Tool<TInputSchema, TOutputSchema, TErrors, TContext> — The tool, which is also an action. Register it with service.tool(tool).

Throws

• When input is not an object schema.

Example

import { defineTool, t } from "@brickkit/core";

export const echoTool = defineTool({
  name: "echo",
  title: "Echo a message",
  description: "Returns the message it is given.",
  input: t.Object({ message: t.String() }),
  output: t.String(),
  execute: ({ input }) => `Echo: ${input.message}`,
});

Source: packages/core/src/tool.ts:33

emitHandlerFactoryCopy Anchor Link

function emitHandlerFactory(route: RouteIR): string

Emits framework code only. User callbacks remain closures bound separately.

Parameters

Returns string

Source: packages/core/src/compiler/emit.ts:4

endpointPathsCopy Anchor Link

function endpointPaths(defs: EndpointDefinition[]): Record<string, any>

OpenAPI paths fragment for declared endpoints (raw HTML included).

Parameters

Returns Record<string, any>

Source: packages/core/src/endpoints.ts:152

ensureResourceIndexesCopy Anchor Link

function ensureResourceIndexes(
  db: any,
  table: any,
  opts: { ownerField?: string; sortFields?: string[]; searchFields?: string[]; } = {},
): void

Ensures secondary indexes exist for a resource table. SQLite: B-tree indexes for owner scope + sort + composite hot path. Postgres: same B-trees plus pg_trgm GIN indexes for substring search. Best-effort: failures warn and continue (e.g. read-only replicas).

Parameters

Source: packages/core/src/db/index.ts:204

ensureSQLiteFtsCopy Anchor Link

function ensureSQLiteFts(db: any, table: any, searchCols: string[]): void

Creates the FTS5 sidecar table + sync triggers + backfills existing rows. Idempotent; safe to call on every resource registration. No-op on Postgres (relies on pg_trgm instead) and when searchCols is empty.

Parameters

Source: packages/core/src/db/index.ts:278

executeCompiledRouteCopy Anchor Link

function executeCompiledRoute(
  plan: CompiledRoutePlan,
  elysiaCtx: any,
): Promise<any>

Answer one request for a compiled route: read the input, run the action, and return its output or the error response, with the x-trace-id and x-request-id headers set. Low level: brick() mounts this for every route.

Parameters

Returns Promise<any> — The action's output, or an error envelope with the status set on set.

Source: packages/core/src/action-handler.ts:149

generateOpenApiSpecCopy Anchor Link

function generateOpenApiSpec(
  options: OpenApiGeneratorOptions = {},
): Record<string, any>

Build the OpenAPI 3.1 document for the services: one path per action route, with request and response schemas from the actions' TypeBox schemas, their declared errors, tags by service, and a bearer security scheme where any action needs authorization.

brick() calls this for /openapi.json; call it yourself to write the document to a file or feed another tool.

Parameters

Returns Record<string, any> — The document as a plain object.

Source: packages/core/src/openapi.ts:114

generateSQLiteIndexDdlCopy Anchor Link

function generateSQLiteIndexDdl(
  table: any,
  opts: { ownerField?: string; sortFields?: string[] } = {},
): string[]

Generates idempotent secondary index DDL for a Drizzle table. Covers owner scoping, sort columns, and exact-match filters. UNIQUE columns already carry an implicit index — skipped here. FTS/trigram indexes are handled separately by the search layer.

Parameters

Returns string[]

Source: packages/core/src/db/index.ts:138

generateSQLiteTableDdlCopy Anchor Link

function generateSQLiteTableDdl(table: any): string

Generates an idempotent SQLite CREATE TABLE IF NOT EXISTS definition directly from a Drizzle table schema.

Parameters

Returns string

Source: packages/core/src/db/index.ts:105

getActionAccessCopy Anchor Link

function getActionAccess(action: Action | object): ActionAccessInfo

How an action is protected: "public" when nothing checks the caller, "authorized" when an authorize does, and "scoped" when the action also limits what rows the caller can reach. It reads what a plugin recorded with setActionAccess, else the action's own authorize, and keeps the policy consistent with the flags.

Parameters

Returns ActionAccessInfo — hasAuthorize, hasScope, and policy.

Source: packages/core/src/access.ts:48

getCompiledCheckCopy Anchor Link

function getCompiledCheck<T extends TSchema>(schema: T): TypeCheck<T>

The compiled validator for a TypeBox schema. Compiling is slow and checking is fast, so each schema is compiled once and kept for as long as the schema object lives.

Parameters

Returns TypeCheck<T> — Its TypeCheck, with Check(value) and Errors(value).

Source: packages/core/src/typebox.ts:18

getGlobalRegistryCopy Anchor Link

function getGlobalRegistry(): ServiceRegistry

The registry every defineService adds to: it is how brick(), the OpenAPI generator, createServiceProxy, and the dashboard find services by name.

Returns ServiceRegistry — The current global registry.

Source: packages/core/src/registry.ts:98

getPluginActionRouteCopy Anchor Link

function getPluginActionRoute(
  action: Action<any, any, any, any>,
  prefix = "/api",
): false | { path: string; method: PluginRouteMethod; clientPath: string[] | undefined; plugin: string; resource: string | undefined; } | undefined

Where a plugin mounted an action over HTTP, for the OpenAPI generator, the compiler, and the typed client.

Parameters

Returns false \| { path: string; method: PluginRouteMethod; clientPath: string[] \| undefined; plugin: string; resource: string \| undefined; } \| undefined — undefined when no plugin bound the action (it uses its own route), false when the plugin's route was switched off, otherwise the route's path and method, the clientPath the typed client uses, and the owning plugin and resource.

Source: packages/core/src/plugin.ts:323

getPluginEndpointsCopy Anchor Link

function getPluginEndpoints(
  service: Service<any, any>,
  prefix = "/api",
): { path: string; method: PluginRouteMethod; service: Service<any, any>; summary: string | undefined; description: string | undefined; tags: string[] | undefined…

The raw HTTP endpoints plugins registered on a service, ready to mount on the application. Each handler resolves the service's context before it runs.

Parameters

Returns { path: string; method: PluginRouteMethod; service: Service<any, any>; summary: string \| undefined; description: string \| undefined; tags: string[] \| undefined; handler: (context: Omit<PluginEndpointContext, "ctx">) => … — The enabled endpoints: path, method, handler, and the summary, description, and tags for OpenAPI.

Source: packages/core/src/plugin.ts:350

hoistAnchoredSchemasCopy Anchor Link

function hoistAnchoredSchemas(spec: Record<string, any>): string[]

TypeBox expresses recursive schemas with bare $id/$ref anchors ({ $id: "T0", ..., { $ref: "T0" } }). OpenAPI interprets a bare $ref as an external file reference, so downstream tooling tries to load a file named T0 and fails. Hoist every anchored subschema into #/components/schemas/ and rewrite the refs to local pointers. First definition wins when one $id is declared twice.

Parameters

Returns string[]

Source: packages/core/src/openapi.ts:47

isBrickAppCopy Anchor Link

function isBrickApp(app: unknown): app is BrickApp

Whether a value is an application made by brick(). It checks for the methods and definition a BrickApp has, so it also recognizes one built by another copy of the package.

Parameters

Returns app is BrickApp — true for a BrickApp, narrowing its type.

Source: packages/core/src/app-entry.ts:11

isBrickServerErrorCopy Anchor Link

function isBrickServerError(err: unknown): err is BrickServerError

Whether an error from the typed client is a BrickServerError: the server answered with a 5xx that is not one of the contract's declared errors, and the error carries its status, url, and body.

Parameters

Returns err is BrickServerError — true for a server error, narrowing its type.

Source: packages/core/src/client.ts:187

isBrickTransportErrorCopy Anchor Link

function isBrickTransportError(err: unknown): err is BrickTransportError

Whether an error from the typed client is a BrickTransportError: the request got no meaningful answer from the server (a network failure, a body that was not JSON, or a 4xx outside the declared contract).

Parameters

Returns err is BrickTransportError — true for a transport error, narrowing its type.

Source: packages/core/src/client.ts:173

isDatabaseHandleCopy Anchor Link

function isDatabaseHandle(value: unknown): value is DatabaseHandle<unknown>

Whether a value is a database handle made by defineDatabase.

Parameters

Returns value is DatabaseHandle<unknown> — true for a handle, narrowing its type.

Source: packages/core/src/db/define.ts:73

isToolCopy Anchor Link

function isTool(value: unknown): value is Tool<any, any, any, any>

Whether a value was made with defineTool, as opposed to defineAction.

Parameters

Returns value is Tool<any, any, any, any> — true for a tool, narrowing its type.

Source: packages/core/src/tool.ts:82

listSecretsCopy Anchor Link

function listSecrets(
  opts: { source?: SecretSource } = {},
): Array<{ name: string; hasDefault: boolean; isSet: boolean }>

Metadata for introspection (values never exposed — future dashboard use).

Parameters

Returns Array<{ name: string; hasDefault: boolean; isSet: boolean }>

Source: packages/core/src/secrets.ts:196

loadCompiledBrickAppCopy Anchor Link

function loadCompiledBrickApp(
  load: () => Promise<{ default: unknown }>,
  ir: BrickIR,
  bind: ApplicationBinder,
): Promise<BrickApp>

Build artifact bootstrap: bind generated handlers while evaluating the original app.

Parameters

Returns Promise<BrickApp>

Source: packages/core/src/compiler.ts:28

overrideSecretCopy Anchor Link

function overrideSecret(name: string, value: string | undefined): void

Test/session override for one secret (undefined clears the override).

Parameters

Source: packages/core/src/secrets.ts:208

overrideSecretsCopy Anchor Link

function overrideSecrets(values: Record<string, string | undefined>): void

Bulk overrides (test/session scoped).

Parameters

Source: packages/core/src/secrets.ts:213

referencePluginCopy Anchor Link

function referencePlugin(opts: ReferenceOptions = {}): Elysia

Standalone Elysia plugin serving GET <path> with the Scalar HTML page.

Parameters

Returns Elysia

Source: packages/core/src/docs.ts:72

registerReferenceRouteCopy Anchor Link

function registerReferenceRoute(
  app: Elysia,
  opts: ReferenceOptions = {},
): Elysia

Mounts the Scalar reference route onto an existing app.

Parameters

Returns Elysia

Source: packages/core/src/docs.ts:85

requestLoggingPluginCopy Anchor Link

function requestLoggingPlugin(opts: RequestLoggingOptions = {}): Elysia

Elysia plugin that logs each request as METHOD path → status (elapsedms). Timing is tracked per-Request via a WeakMap. The onError hook only logs and returns undefined so existing error mapping is preserved. Logging only — no CORS headers are set here.

Hooks are registered with the "global" scope so they propagate to the parent app when mounted via app.use(...) — Elysia scopes plain instance hooks to the plugin's own routes. Timing is captured in beforeHandle because request hooks are not propagated from a used instance. Unmatched routes (no beforeHandle) fall back to Date.now().

Parameters

Returns Elysia

Source: packages/core/src/request-logger.ts:41

requireBrickAppCopy Anchor Link

function requireBrickApp(app: unknown): BrickApp

Check that a module's default export is an application ready to be served, for tools that load an entry file.

Parameters

Returns BrickApp — The app.

Throws

• When it is not a BrickApp, or it already called .listen(): the entry must only build the app, and leave listening to the server bootstrap.

Source: packages/core/src/app-entry.ts:39

resetGlobalRegistryCopy Anchor Link

function resetGlobalRegistry(): void

Start over with an empty global registry. For tests, which define the same services again in each case; an application never needs it.

Source: packages/core/src/registry.ts:106

resetSecretsCopy Anchor Link

function resetSecrets(): void

Clear registry and overrides. Test-only.

Source: packages/core/src/secrets.ts:222

resolveEndpointDbCopy Anchor Link

function resolveEndpointDb(
  service: Service<any, any> | string | undefined,
  services: Service<any, any>[],
): any

Resolve the db for an endpoint: explicit service first, else first service holding one.

Parameters

Returns any

Source: packages/core/src/endpoints.ts:52

resolveSecretsCopy Anchor Link

function resolveSecrets(
  opts: { source?: SecretSource } = {},
): Record<string, unknown>

Validate every registered secret at boot. Throws a single error listing all missing required secrets. Returns the resolved values.

Parameters

Returns Record<string, unknown>

Source: packages/core/src/secrets.ts:176

scalarDocsHTMLCopy Anchor Link

function scalarDocsHTML(specUrl: string, title: string): string

Renders the Scalar API reference page for the given OpenAPI URL.

Parameters

Returns string

Source: packages/core/src/docs.ts:48

secretCopy Anchor Link

function secret(name: string, options: SecretOptions = {}): SecretRef<string>

Declare a secret. Idempotent: re-declaring the same name returns the original ref (first declaration wins) so module re-evaluation is safe.

Parameters

Returns SecretRef<string>

Source: packages/core/src/secrets.ts:161

setActionAccessCopy Anchor Link

function setActionAccess(action: object, info: ActionAccessInfo): void

Record how an action is protected, for tools that cannot read it from the configuration: plugins such as crud enforce access inside execute, so the action has no authorize to find. Introspection, OpenAPI, and the dashboard read what is recorded here.

Parameters

Source: packages/core/src/access.ts:30

swaggerDocsHTMLCopy Anchor Link

function swaggerDocsHTML(specUrl: string, title: string): string

Renders the Swagger UI page.

Parameters

Returns string

Source: packages/core/src/docs.ts:93

syncSchemaCopy Anchor Link

function syncSchema(
  tablesOrService: Map<string, any> | any[] | Record<string, any> | Service,
  dbInstance?: any,
): Promise<void> | void

Explicit SQLite development/test schema preparation helper. Never called by services, resources, auth, or server startup. Not a migration runner; PostgreSQL schema management is caller-owned.

Parameters

Returns Promise<void> \| void

Source: packages/core/src/db/index.ts:365

toErrorResponseCopy Anchor Link

function toErrorResponse(err: unknown, context: ErrorContext): ErrorEnvelope

Turn what an action threw into the JSON body of its HTTP response, and record the failure on the active trace. Declared failures and validation errors keep their code, status, and details; anything else is logged and answered as a generic INTERNAL_SERVER_ERROR (500) so internals are never exposed.

Parameters

Returns ErrorEnvelope — The envelope: name, code, message, status, requestId, and details or errors when there are any.

Source: packages/core/src/error-response.ts:46

toOpenApiPathCopy Anchor Link

function toOpenApiPath(elysiaPath: string): string

/p/:slug → /p/{slug} for OpenAPI.

Parameters

Returns string

Source: packages/core/src/endpoints.ts:142

traceRouteCopy Anchor Link

function traceRoute<T>(
  route: string,
  handler: (context: RawRouteContext) => T,
): (context: RawRouteContext) => T

Wrap a raw route handler so each of its requests gets a server span. Use it for routes registered directly on the app, outside actions and endpoints, such as auth or webhook routes. Spans are recorded whenever a tracer provider is registered; brick({ telemetry }) does not apply to these routes.

The wrapper forwards only the fields listed in RawRouteContext. Elysia decides what to parse from the handler's destructuring, and forwarding the whole context would parse the body and leave request.json() with nothing.

Parameters

Returns (context: RawRouteContext) => T

Source: packages/core/src/telemetry.ts:75

validateWithSchemaCopy Anchor Link

function validateWithSchema<T extends TSchema>(
  schema: T | undefined,
  value: unknown,
): | { success: true; data: Static<T> } | { success: false; errors: ValidationErrorItem[] }

Check a value against a schema, the way actions check their input and output.

Parameters

Returns \| { success: true; data: Static<T> } \| { success: false; errors: ValidationErrorItem[] } — { success: true, data }, or { success: false, errors } with a path, message, type, and the offending value for each problem.

Source: packages/core/src/typebox.ts:35

ClassesCopy Anchor Link

ActionExecutionErrorCopy Anchor Link

class ActionExecutionError extends Error

Constructor

Properties

Methods

Source: packages/core/src/types.ts:101

BrickServerErrorCopy Anchor Link

class BrickServerError extends Error

The server answered 5xx without a declared code / ValidationError shape, i.e. an unexpected failure rather than a modelled domain error.

Constructor

Properties

Source: packages/core/src/client.ts:147

BrickTransportErrorCopy Anchor Link

class BrickTransportError extends Error

The request never received a meaningful server answer: DNS / connection failure, a malformed body, or a 4xx response outside the declared contract (no code and no ValidationError shape).

Constructor

Properties

Source: packages/core/src/client.ts:123

SecretRefCopy Anchor Link

class SecretRef<T = string>

Constructor

Properties

Methods

Source: packages/core/src/secrets.ts:42

ServiceImplCopy Anchor Link

class ServiceImpl<TDb = BunSQLiteDatabase<Record<string, unknown>>, TServiceContext extends Record<string, any> = Record<string, any>> implements Service<TDb, TServiceContext>

Constructor

Properties

Methods

Source: packages/core/src/service.ts:46

ServiceRegistryCopy Anchor Link

class ServiceRegistry

Properties

Methods

Source: packages/core/src/registry.ts:9

UnknownToolErrorCopy Anchor Link

class UnknownToolError extends Error

Constructor

Source: packages/core/src/mcp.ts:25

ValidationErrorCopy Anchor Link

class ValidationError extends Error

Constructor

Properties

Methods

Source: packages/core/src/types.ts:74

InterfacesCopy Anchor Link

ActionCopy Anchor Link

interface Action<TInputSchema extends TSchema | undefined = any, TOutputSchema extends TSchema | undefined = any, TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>, TContext extends ActionContext = ActionContext>

Properties

Methods

Source: packages/core/src/types.ts:261

ActionAccessInfoCopy Anchor Link

interface ActionAccessInfo

Properties

Source: packages/core/src/access.ts:4

ActionConfigWithAuthorizeCopy Anchor Link

interface ActionConfigWithAuthorize<TInputSchema extends TSchema | undefined = undefined, TOutputSchema extends TSchema | undefined = undefined, TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>, TContext extends ActionContext = ActionContext> extends BaseActionConfig<TInputSchema, TOutputSchema, TErrors>

Properties

Source: packages/core/src/types.ts:202

ActionConfigWithoutAuthorizeCopy Anchor Link

interface ActionConfigWithoutAuthorize<TInputSchema extends TSchema | undefined = undefined, TOutputSchema extends TSchema | undefined = undefined, TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>, TContext extends ActionContext = ActionContext> extends BaseActionConfig<TInputSchema, TOutputSchema, TErrors>

Properties

Source: packages/core/src/types.ts:225

ActionErrorDefinitionCopy Anchor Link

interface ActionErrorDefinition

Properties

Source: packages/core/src/types.ts:62

ActionSchemaCopy Anchor Link

interface ActionSchema

Properties

Source: packages/core/src/types.ts:480

ApiDocumentCopy Anchor Link

interface ApiDocument

A named OpenAPI document ready to render.

Properties

Source: packages/core/src/docs.ts:17

ArchitectureSchemaCopy Anchor Link

interface ArchitectureSchema

Properties

Source: packages/core/src/types.ts:517

BaseActionConfigCopy Anchor Link

interface BaseActionConfig<TInputSchema extends TSchema | undefined = undefined, TOutputSchema extends TSchema | undefined = undefined, TErrors extends Record<string, ActionErrorDefinition> = Record<string, ActionErrorDefinition>>

Properties

Source: packages/core/src/types.ts:181

BaseContextCopy Anchor Link

interface BaseContext<TDb = any>

Base framework context supplied to all service resolvers and action executions.

Properties

Source: packages/core/src/types.ts:23

BrickCallOptionsCopy Anchor Link

interface BrickCallOptions

Properties

Source: packages/core/src/client.ts:109

BrickClientActionCopy Anchor Link

interface BrickClientAction<TInput = unknown, TOutput = unknown, TErrors = {}>

Browser-safe action metadata generated by the Brick Vite plugin.

Properties