@brickkit/core/client

@brickkit/core/client exports 14 names: 3 functions, 2 classes, 3 interfaces, 6 types.

import { BrickServerError, BrickTransportError, createBrickClient } from "@brickkit/core/client";

FunctionsCopy Anchor Link

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

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

ClassesCopy Anchor Link

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

InterfacesCopy Anchor Link

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

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

BrickClientOptionsCopy Anchor Link

interface BrickClientOptions

Eden/tRPC-style typed HTTP client inferred from Brick-TS application contracts.

The frontend imports only the contract type — never a backend implementation:

import { createBrickClient } from "@brickkit/core/client";
import type { AppServer } from "./server"; // `import type`: erased at build

const api = createBrickClient<AppServer>({ baseUrl: "http://localhost:4000" });
const pages = await api.page.list({ limit: 10, sort: "-createdAt" });
const created = await api.page.create({ title: "Hello", content: "World" });

Build the contract from individually-typed actions (each defineAction call preserves its input/output/error literal types):

// server.ts (backend)
export const listPages = pagesService.action({ name: "page.list", ... });
export const createPage = pagesService.action({ name: "page.create", ... });
export const contract = { page: { list: listPages, create: createPage } };
export type AppServer = typeof contract;

Result / error convention

The client uses a throw-based convention that mirrors local action.execute semantics, because TypeScript promises cannot encode thrown exception types:

• Success → the promise resolves with the action output.
• Declared domain failures (your errors: { SLUG_EXISTS: ... }) and framework guards (UNAUTHORIZED/FORBIDDEN/NOT_FOUND/...) → rejected with ActionExecutionError carrying the declared code, status, message, and details. Narrow with instanceof and read err.code.
• Input/output validation failures → rejected with ValidationError, exactly as local execution throws.
• Network failures, unparsable bodies, and non-OK responses outside the declared contract → BrickTransportError (4xx) or BrickServerError (5xx).
• Cancellation via AbortSignal → the native AbortError propagates unwrapped so err.name === "AbortError" keeps working.

URL mapping

A client path is a namespace walk ending in an action call. The leaf segment decides the route, matching the server compiler (packages/cli/src/compiler):

Properties

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

TypesCopy Anchor Link

BrickActionCallerCopy Anchor Link

type BrickActionCaller<A> =
  undefined extends InferActionInput<A>
    ? (
        input?: InferActionInput<A>,
        options?: BrickCallOptions,
      ) => Promise<InferActionOutput<A>>
    : (
        input: InferActionInput<A>,
        options?: BrickCallOptions,
      ) => Promise<InferActionOutput<A>>;

Typed caller for one action. Required inputs stay required; actions whose input includes undefined (no schema / all-optional) can be called bare.

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

BrickClientCopy Anchor Link

type BrickClient<T> = T extends
  | BrickClientAction<any, any, any>
  | Action<any, any, any, any>
  ? BrickActionCaller<T>
  : T extends (...args: any[]) => any
    ? BrickActionCaller<T>
    : T extends object
      ? { [K in keyof T]: BrickClient<T[K]> }
      : T;

Recursively maps action leaves and their namespaces to browser callers.

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

InferActionErrorCodesCopy Anchor Link

type InferActionErrorCodes<A> =
  A extends BrickClientAction<any, any, infer E>
    ? Extract<keyof E, string>
    : A extends {
          config: { errors?: infer E };
        }
      ? E extends Record<string, ActionErrorDefinition>
        ? Extract<keyof E, string>
        : never
      : never;

Union of error codes declared in an action's errors map.

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

InferActionFailureCopy Anchor Link

type InferActionFailure<A> = ActionExecutionError & {
  code:
    | InferActionErrorCodes<A>
    | "BAD_REQUEST"
    | "UNAUTHORIZED"
    | "FORBIDDEN"
    | "NOT_FOUND"
    | "CONFLICT"
    | "INTERNAL_SERVER_ERROR"
    | "VALIDATION_FAILED";
};

The declared failure shape of an action for catch narrowing:

try { await api.page.create(input); }
catch (err) {
  if (err instanceof ActionExecutionError) {
    const code: InferActionErrorCodes<typeof createPage> | "UNAUTHORIZED" | ... = err.code;
  }
}

(Standard framework codes are always possible alongside declared ones.)

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

InferActionInputCopy Anchor Link

type InferActionInput<A> =
  A extends BrickClientAction<infer I, any, any>
    ? I
    : A extends {
          config: { input?: infer S extends TSchema };
        }
      ? Static<S>
      : A extends {
            execute(params: { input?: infer I; ctx?: any }): any;
          }
        ? I
        : A extends { run(input?: infer I, ctx?: any): any }
          ? I
          : A extends (params: { input?: infer I; ctx?: any }) => any
            ? I
            : unknown;

Static input type from the schema, with a fallback for structural actions.

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

InferActionOutputCopy Anchor Link

type InferActionOutput<A> =
  A extends BrickClientAction<any, infer O, any>
    ? O
    : A extends (...args: any[]) => Promise<infer O>
      ? O
      : A extends { execute(params: any): Promise<infer O> }
        ? O
        : unknown;

Resolved output type of an action.

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