@brickkit/core 0.4.2 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,118 +1,100 @@
1
1
  # @brickkit/core
2
2
 
3
- Services, actions, resources, and databases for the Brick-TS framework. You define typed services with TypeBox schemas, mount them with `brick()`, and get an Elysia HTTP server with OpenAPI output and a typed client.
4
-
5
- You need Bun 1.2 or later. Bun-only APIs are lazy-loaded, so the package imports cleanly under strict Node ESM too.
6
-
7
- ```sh
8
- bun add @brickkit/core
9
- ```
10
-
11
- ## Define a service
12
-
13
- Create a service, register an action on it, and serve it. Each action exposes one route: `POST /api/{service}/{action}` by default.
3
+ The Effect-native kernel of Brick. Declare typed actions once; Brick serves them
4
+ as HTTP endpoints (with OpenAPI), RPC methods, and MCP tools.
14
5
 
15
6
  ```ts
16
- import { brick, defineAction, defineService } from "@brickkit/core";
17
-
18
- const healthService = defineService("system");
19
- const ping = defineAction({
20
- name: "ping",
21
- execute: async () => ({ status: "ok" }),
7
+ import { Brick } from "@brickkit/core";
8
+ import { NotFound } from "@brickkit/core/contracts";
9
+ import { Effect, Layer, Schema } from "effect";
10
+
11
+ const GetUser = Brick.action("getUser", "/api/users/getUser", {
12
+ input: Schema.Struct({ id: Schema.String }),
13
+ output: Schema.Struct({ id: Schema.String, name: Schema.String }),
14
+ errors: [NotFound],
22
15
  });
23
- healthService.action(ping);
24
-
25
- const app = brick({ services: [healthService] });
26
- app.listen(4000);
27
- ```
28
-
29
- Set `method: "GET"` on the action config to serve reads over GET, or `path` to replace the default route. Add `input` and `output` TypeBox schemas to validate at the boundary. Add `authorize` to require a user; without it the action is public. To call an action in process with the same pipeline, use `action.run(input, ctx)` or `service.getAction("ping")`.
30
-
31
- `brick()` also accepts `prefix`, `title`, and `version`. `generateOpenApiSpec({ services, prefix })` returns the OpenAPI 3.1 document without starting a server.
32
-
33
- ## Exports
34
16
 
35
- | Path | What it holds |
36
- | ----------------------- | --------------------------------------------------------------- |
37
- | `@brickkit/core` | `brick`, `defineService`, `defineAction`, `defineDatabase`, MCP |
38
- | `@brickkit/core/client` | `createBrickClient`, the Eden-style typed browser client |
39
- | `@brickkit/core/pg` | Postgres Drizzle table helpers such as `pgTable` |
17
+ // Handlers are Effects: failures must be declared in `errors`, and any
18
+ // service they require must be provided by the app's `layer`.
19
+ const getUser = GetUser(({ id }) =>
20
+ id === "usr_42"
21
+ ? Effect.succeed({ id, name: "Ada" })
22
+ : Effect.fail(new NotFound({ message: "User not found" })),
23
+ );
40
24
 
41
- Databases use Drizzle tables through `defineDatabase({ engine, tables, url })` with `"sqlite"` or `"postgres"` engines. Database setup is documented in `DATABASES.md`.
25
+ const users = Brick.service("users", { actions: { getUser } });
26
+ export const app = Brick.app({ services: [users], layer: Layer.empty });
42
27
 
43
- ```sh
44
- bun add @brickkit/core drizzle-orm postgres
28
+ Bun.serve({ port: 3000, fetch: app.fetch });
45
29
  ```
46
30
 
47
- ```ts
48
- import { defineDatabase } from "@brickkit/core";
49
- import { pgTable, text } from "@brickkit/core/pg";
50
-
51
- const pages = pgTable("pages", {
52
- id: text("id").primaryKey(),
53
- title: text("title").notNull(),
54
- });
31
+ ## API
55
32
 
56
- export const db = defineDatabase({
57
- engine: "postgres",
58
- tables: { pages },
59
- url: process.env.DATABASE_URL!,
60
- });
61
- ```
33
+ | Export | Purpose |
34
+ | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
35
+ | `Brick.action(name, path, schemas)` | Contract + handler factory: input, output, declared errors, optional `mcp`, `title`, `description` |
36
+ | `Brick.endpoint(name, method, path, schemas)` | Like `action`, with typed `params`, `query`, `payload`, `headers` |
37
+ | `Brick.service(name, { actions })` | Groups actions into an HTTP API group |
38
+ | `Brick.app({ services, layer, transports?, routes?, docs? })` | Compiles services into one scoped application |
39
+ | `Brick.route(method, path, effect)` | Raw HTTP route outside the action contract |
40
+ | `Brick.rpcGroup(actions)` | Effect RPC group for service-to-service calls |
41
+ | `secret`, `envSource`, ... | Typed secrets, validated at startup |
62
42
 
63
- ## Typed client
43
+ `Brick.app` returns `{ fetch, ready, dispose, layer, api, openApi() }`.
44
+ `fetch` starts the application lazily; `dispose` interrupts in-flight
45
+ requests and releases every scoped resource once.
64
46
 
65
- `@brickkit/core/client` (also re-exported from the package root) offers an Eden-style HTTP client inferred from your contract type — no OpenAPI codegen:
47
+ ## Typed errors
66
48
 
67
- With the Brick Vite plugin configured for your default-exported app, Vite creates `_brick/contract.ts` automatically:
49
+ Errors are `Schema.TaggedError` classes, so they are values in the type
50
+ system, carry their HTTP status, and cross the wire with their type intact.
51
+ `@brickkit/core/contracts` exports `BadRequest`, `Unauthorized`, `Forbidden`,
52
+ `NotFound`, `Conflict`, and `InternalServerError`. Define your own:
68
53
 
69
54
  ```ts
70
- import { createBrickClient } from "@brickkit/core/client";
71
- import { contract } from "../_brick/contract";
72
-
73
- const api = createBrickClient({ baseUrl: "http://localhost:4000", contract });
74
- const pages = await api.page.list({ limit: 10 });
55
+ export class SlugTaken extends Schema.TaggedError<SlugTaken>()(
56
+ "SlugTaken",
57
+ { slug: Schema.String },
58
+ { httpApiStatus: 409 },
59
+ ) {}
75
60
  ```
76
61
 
77
- The generated contract contains browser-safe route metadata and inferred input/output/error types. It honors custom action paths and methods, encodes path parameters, and removes them from the remaining payload. No backend handlers are bundled. See the CLI README and `www/content/docs/(brick)/typed-client.mdx` for Vite setup and error handling.
62
+ Failing with an error that the action did not declare is a compile error.
63
+ Unexpected failures are defects and are returned as a redacted 500.
78
64
 
79
- ## MCP tools
65
+ ## Dependencies
80
66
 
81
- Define tools like actions, with typed input/output schemas and inline metadata:
67
+ Provide services through the app's `layer`. An action that requires a service
68
+ the layer does not supply does not type-check.
82
69
 
83
- ```ts
84
- import {
85
- defineService,
86
- createMcpRegistry,
87
- createMcpHandler,
88
- t,
89
- } from "@brickkit/core";
90
-
91
- const crm = defineService("crm");
92
- const whoami = crm.tool({
93
- name: "crm_whoami",
94
- title: "View Connected CRM Account",
95
- annotations: { readOnlyHint: true },
96
- input: t.Object({}),
97
- output: t.String(),
98
- authorize: ({ user }) => !!user?.id,
99
- execute: ({ ctx }) => ctx.user.id,
100
- });
70
+ ## Transports
101
71
 
102
- const registry = createMcpRegistry({ services: [crm] });
103
- registry.listTools();
104
- await registry.callTool("crm_whoami", {}, { user: { id: "user_1" } });
105
-
106
- const handleMcp = createMcpHandler({
107
- registry,
108
- serverInfo: { name: "crm", version: "1.0.0" },
72
+ ```ts
73
+ import { McpProtocol } from "effect/ai";
74
+
75
+ Brick.app({
76
+ services: [users],
77
+ layer,
78
+ transports: {
79
+ rpc: { path: "/rpc" },
80
+ mcp: {
81
+ name: "users",
82
+ version: "1.0.0",
83
+ path: "/mcp",
84
+ protocols: [McpProtocol.v2025_11_25],
85
+ },
86
+ },
87
+ docs: { path: "/reference" },
109
88
  });
110
- // After your app authenticates a request:
111
- // return handleMcp(request, { user: { id: verifiedSubject } });
112
89
  ```
113
90
 
114
- Tools use action validation, authorization, and service context. They are stored separately from HTTP actions and stay out of routes and OpenAPI by default, including when their service is passed to `brick()`. Add `http: true` to a tool definition, or register it with `crm.action(whoami)`, to expose it over HTTP as well.
91
+ Only actions declared with `mcp: true` are exposed as MCP tools. The MCP
92
+ options are those of Effect's `McpServer.layerHttp`.
115
93
 
116
- The registry accepts `services` and/or an explicit `tools` array, rejects duplicate names, and reads annotations directly from definitions. The handler is a stateless POST JSON-RPC helper for initialize, ping, tools/list, and tools/call; notifications receive an empty 202 response. Authentication and mounting remain in your app. Its default protocol version is `2025-06-18`, following the [MCP tools specification](https://modelcontextprotocol.io/specification/2025-06-18/server/tools).
94
+ ## Entry points
117
95
 
118
- Source: <https://github.com/Chandraprakash-Darji/brick>.
96
+ | Import | Contents |
97
+ | -------------------------- | ----------------------------------------------------------------------- |
98
+ | `@brickkit/core` | `Brick`, `isNativeBrickApp`, secrets |
99
+ | `@brickkit/core/contracts` | `action`, `endpoint`, and standard errors; browser-safe, no server code |
100
+ | `@brickkit/core/pg` | Drizzle `pg-core` re-exports, for a single Drizzle copy |
@@ -0,0 +1,151 @@
1
+ import { Effect, Schema } from "effect";
2
+ import { HttpApiEndpoint, HttpApiSchema } from "effect/http-api";
3
+ import { Rpc } from "effect/rpc";
4
+ import { Tool } from "effect/ai";
5
+ import { HttpMethod } from "effect/http/HttpMethod";
6
+ //#region src/native/contracts.d.ts
7
+ declare const action: <const N extends string, I extends Schema.Top, O extends Schema.Top, const Errors extends readonly Schema.Top[]>(name: N, path: `/${string}`, schemas: {
8
+ input: I;
9
+ output: O;
10
+ errors: Errors;
11
+ mcp?: boolean;
12
+ description?: string;
13
+ title?: string;
14
+ tool?: {
15
+ readonly readOnly?: boolean;
16
+ readonly destructive?: boolean;
17
+ readonly idempotent?: boolean;
18
+ readonly openWorld?: boolean;
19
+ };
20
+ }) => (<Failure extends Errors[number]["Type"], R>(handler: (input: I["Type"]) => Effect.Effect<O["Type"], Failure, R>) => Readonly<{
21
+ handler: (input: I["Type"]) => Effect.Effect<O["Type"], Failure, Exclude<R, import("effect/Tracer").ParentSpan>>;
22
+ httpHandler: ({ payload }: {
23
+ payload: I["Type"];
24
+ }) => Effect.Effect<O["Type"], Failure, Exclude<R, import("effect/Tracer").ParentSpan>>;
25
+ name: N;
26
+ endpoint: HttpApiEndpoint.HttpApiEndpoint<N, "POST", `/${string}`, never, never, [I extends Schema.Struct.Fields ? Schema.Struct<I> : I extends readonly Schema.Constraint[] ? I[number] : I] extends [never] ? never : [I extends Schema.Struct.Fields ? Schema.Struct<I> : I extends readonly Schema.Constraint[] ? I[number] : I] extends [Schema.Constraint] ? Schema.toCodecJson<Schema.Constraint & (I extends Schema.Struct.Fields ? Schema.Struct<I> : I extends readonly Schema.Constraint[] ? I[number] : I)> : never, never, [Exclude<Extract<O extends readonly (infer A)[] ? A : O, Schema.Top>, HttpApiSchema.WithHeaders<Schema.Top, Schema.Top> | HttpApiSchema.StreamSchema>] extends [never] ? ((O extends readonly (infer A)[] ? A : O) extends (infer Success) ? Success extends HttpApiSchema.StreamSchema ? Success : never : never) | ((O extends readonly (infer A)[] ? A : O) extends (infer Success_1) ? Success_1 extends HttpApiSchema.WithHeaders<infer _Inner extends Schema.Top, infer _Headers extends Schema.Top> ? HttpApiSchema.WithHeaders<_Inner extends HttpApiSchema.StreamSchema ? _Inner : Schema.toCodecJson<_Inner>, Schema.toCodecStringTree<_Headers>> : never : never) : ((O extends readonly (infer A)[] ? A : O) extends (infer Success) ? Success extends HttpApiSchema.StreamSchema ? Success : never : never) | ((O extends readonly (infer A)[] ? A : O) extends (infer Success_1) ? Success_1 extends HttpApiSchema.WithHeaders<infer _Inner extends Schema.Top, infer _Headers extends Schema.Top> ? HttpApiSchema.WithHeaders<_Inner extends HttpApiSchema.StreamSchema ? _Inner : Schema.toCodecJson<_Inner>, Schema.toCodecStringTree<_Headers>> : never : never) | Schema.toCodecJson<Exclude<Extract<O extends readonly (infer A)[] ? A : O, Schema.Top>, HttpApiSchema.WithHeaders<Schema.Top, Schema.Top> | HttpApiSchema.StreamSchema>>, [Schema.Union<readonly [Schema.Union<Errors>]>] extends [Schema.Constraint] ? Schema.toCodecJson<Schema.Constraint & Schema.Union<readonly [Schema.Union<Errors>]>> : never, never, never>;
27
+ method: HttpMethod;
28
+ path: `/${string}`;
29
+ rpc: Rpc.Rpc<N, I extends Schema.Struct.Fields ? Schema.Struct<I> : I, O, Schema.Union<Errors>, never, never>;
30
+ tool: Tool.Tool<N, {
31
+ readonly parameters: I;
32
+ readonly success: O;
33
+ readonly failure: Schema.Union<Errors>;
34
+ readonly failureMode: "error";
35
+ }, never>;
36
+ mcp: boolean;
37
+ }>) & Readonly<{
38
+ name: N;
39
+ endpoint: HttpApiEndpoint.HttpApiEndpoint<N, "POST", `/${string}`, never, never, [I extends Schema.Struct.Fields ? Schema.Struct<I> : I extends readonly Schema.Constraint[] ? I[number] : I] extends [never] ? never : [I extends Schema.Struct.Fields ? Schema.Struct<I> : I extends readonly Schema.Constraint[] ? I[number] : I] extends [Schema.Constraint] ? Schema.toCodecJson<Schema.Constraint & (I extends Schema.Struct.Fields ? Schema.Struct<I> : I extends readonly Schema.Constraint[] ? I[number] : I)> : never, never, [Exclude<Extract<O extends readonly (infer A)[] ? A : O, Schema.Top>, HttpApiSchema.WithHeaders<Schema.Top, Schema.Top> | HttpApiSchema.StreamSchema>] extends [never] ? ((O extends readonly (infer A)[] ? A : O) extends (infer Success) ? Success extends HttpApiSchema.StreamSchema ? Success : never : never) | ((O extends readonly (infer A)[] ? A : O) extends (infer Success_1) ? Success_1 extends HttpApiSchema.WithHeaders<infer _Inner extends Schema.Top, infer _Headers extends Schema.Top> ? HttpApiSchema.WithHeaders<_Inner extends HttpApiSchema.StreamSchema ? _Inner : Schema.toCodecJson<_Inner>, Schema.toCodecStringTree<_Headers>> : never : never) : ((O extends readonly (infer A)[] ? A : O) extends (infer Success) ? Success extends HttpApiSchema.StreamSchema ? Success : never : never) | ((O extends readonly (infer A)[] ? A : O) extends (infer Success_1) ? Success_1 extends HttpApiSchema.WithHeaders<infer _Inner extends Schema.Top, infer _Headers extends Schema.Top> ? HttpApiSchema.WithHeaders<_Inner extends HttpApiSchema.StreamSchema ? _Inner : Schema.toCodecJson<_Inner>, Schema.toCodecStringTree<_Headers>> : never : never) | Schema.toCodecJson<Exclude<Extract<O extends readonly (infer A)[] ? A : O, Schema.Top>, HttpApiSchema.WithHeaders<Schema.Top, Schema.Top> | HttpApiSchema.StreamSchema>>, [Schema.Union<readonly [Schema.Union<Errors>]>] extends [Schema.Constraint] ? Schema.toCodecJson<Schema.Constraint & Schema.Union<readonly [Schema.Union<Errors>]>> : never, never, never>;
40
+ method: HttpMethod;
41
+ path: `/${string}`;
42
+ rpc: Rpc.Rpc<N, I extends Schema.Struct.Fields ? Schema.Struct<I> : I, O, Schema.Union<Errors>, never, never>;
43
+ tool: Tool.Tool<N, {
44
+ readonly parameters: I;
45
+ readonly success: O;
46
+ readonly failure: Schema.Union<Errors>;
47
+ readonly failureMode: "error";
48
+ }, never>;
49
+ mcp: boolean;
50
+ }>;
51
+ type HttpInputKey = "params" | "query" | "payload" | "headers";
52
+ type Part<I, K extends HttpInputKey> = K extends keyof I ? I[K] : never;
53
+ type ParamCodec<S> = [S] extends [never] ? never : S extends Schema.Top ? Schema.toCodecStringTree<S> : never;
54
+ type PayloadCodec<S> = [S] extends [never] ? never : S extends Schema.Top ? Schema.toCodecJson<S> : never;
55
+ type SuccessCodec<S> = [S] extends [never] ? typeof HttpApiSchema.NoContent : S extends Schema.Top ? Schema.toCodecJson<S> : never;
56
+ type ErrorCodec<E extends readonly Schema.Top[]> = [E] extends [never] ? never : Schema.toCodecJson<Schema.Union<[Schema.Union<E>]>>;
57
+ /** Typed HTTP request parts also form the input contract for local/RPC/tool calls. */
58
+ declare const endpoint: <const N extends string, const M extends HttpMethod, const I extends Record<string, Schema.Top>, O extends Schema.Top, const Errors extends readonly Schema.Top[]>(name: N, method: M, path: `/${string}`, schemas: {
59
+ readonly input: I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
60
+ readonly payload?: never;
61
+ } : unknown);
62
+ readonly output: O;
63
+ readonly errors: Errors;
64
+ readonly mcp?: boolean;
65
+ readonly description?: string;
66
+ readonly title?: string;
67
+ }) => (<Failure extends Errors[number]["Type"], R>(handler: (input: Schema.Struct.View<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
68
+ readonly payload?: never;
69
+ } : unknown), "Type", Schema.Struct.TypeOptionalKeys<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
70
+ readonly payload?: never;
71
+ } : unknown)>, Schema.Struct.TypeMutableKeys<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
72
+ readonly payload?: never;
73
+ } : unknown)>>) => Effect.Effect<O["Type"], Failure, R>) => Readonly<{
74
+ method: HttpMethod;
75
+ endpoint: HttpApiEndpoint.HttpApiEndpoint<N, M, `/${string}`, ParamCodec<Part<I, "params">>, ParamCodec<Part<I, "query">>, PayloadCodec<Part<I, "payload">>, ParamCodec<Part<I, "headers">>, SuccessCodec<O>, ErrorCodec<Errors>, never, never>;
76
+ httpHandler: (input: Schema.Struct.View<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
77
+ readonly payload?: never;
78
+ } : unknown), "Type", Schema.Struct.TypeOptionalKeys<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
79
+ readonly payload?: never;
80
+ } : unknown)>, Schema.Struct.TypeMutableKeys<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
81
+ readonly payload?: never;
82
+ } : unknown)>>) => Effect.Effect<O["Type"], Failure, Exclude<R, import("effect/Tracer").ParentSpan>>;
83
+ handler: (input: Schema.Struct.View<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
84
+ readonly payload?: never;
85
+ } : unknown), "Type", Schema.Struct.TypeOptionalKeys<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
86
+ readonly payload?: never;
87
+ } : unknown)>, Schema.Struct.TypeMutableKeys<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
88
+ readonly payload?: never;
89
+ } : unknown)>>) => Effect.Effect<O["Type"], Failure, Exclude<R, import("effect/Tracer").ParentSpan>>;
90
+ name: N;
91
+ path: `/${string}`;
92
+ rpc: Rpc.Rpc<N, Schema.Struct<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
93
+ readonly payload?: never;
94
+ } : unknown)>, O, Schema.Union<Errors>, never, never>;
95
+ tool: Tool.Tool<N, {
96
+ readonly parameters: Schema.Struct<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
97
+ readonly payload?: never;
98
+ } : unknown)>;
99
+ readonly success: O;
100
+ readonly failure: Schema.Union<Errors>;
101
+ readonly failureMode: "error";
102
+ }, never>;
103
+ mcp: boolean;
104
+ }>) & {
105
+ name: N;
106
+ method: HttpMethod;
107
+ endpoint: HttpApiEndpoint.HttpApiEndpoint<N, M, `/${string}`, ParamCodec<Part<I, "params">>, ParamCodec<Part<I, "query">>, PayloadCodec<Part<I, "payload">>, ParamCodec<Part<I, "headers">>, SuccessCodec<O>, ErrorCodec<Errors>, never, never>;
108
+ path: `/${string}`;
109
+ rpc: Rpc.Rpc<N, Schema.Struct<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
110
+ readonly payload?: never;
111
+ } : unknown)>, O, Schema.Union<Errors>, never, never>;
112
+ tool: Tool.Tool<N, {
113
+ readonly parameters: Schema.Struct<I & Record<Exclude<keyof I, HttpInputKey>, never> & (M extends HttpMethod.NoBody ? {
114
+ readonly payload?: never;
115
+ } : unknown)>;
116
+ readonly success: O;
117
+ readonly failure: Schema.Union<Errors>;
118
+ readonly failureMode: "error";
119
+ }, never>;
120
+ mcp: boolean;
121
+ };
122
+ declare namespace errors_d_exports {
123
+ export { BadRequest, Conflict, Forbidden, InternalServerError, NotFound, Unauthorized };
124
+ }
125
+ declare const BadRequest_base: Schema.Class<BadRequest, Schema.TaggedStruct<"BadRequest", {
126
+ readonly message: Schema.String;
127
+ }>, import("effect/Cause").YieldableError>;
128
+ declare class BadRequest extends BadRequest_base {}
129
+ declare const Unauthorized_base: Schema.Class<Unauthorized, Schema.TaggedStruct<"Unauthorized", {
130
+ readonly message: Schema.String;
131
+ }>, import("effect/Cause").YieldableError>;
132
+ declare class Unauthorized extends Unauthorized_base {}
133
+ declare const Forbidden_base: Schema.Class<Forbidden, Schema.TaggedStruct<"Forbidden", {
134
+ readonly message: Schema.String;
135
+ }>, import("effect/Cause").YieldableError>;
136
+ declare class Forbidden extends Forbidden_base {}
137
+ declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
138
+ readonly message: Schema.String;
139
+ }>, import("effect/Cause").YieldableError>;
140
+ declare class NotFound extends NotFound_base {}
141
+ declare const Conflict_base: Schema.Class<Conflict, Schema.TaggedStruct<"Conflict", {
142
+ readonly message: Schema.String;
143
+ }>, import("effect/Cause").YieldableError>;
144
+ declare class Conflict extends Conflict_base {}
145
+ declare const InternalServerError_base: Schema.Class<InternalServerError, Schema.TaggedStruct<"InternalServerError", {
146
+ readonly message: Schema.String;
147
+ }>, import("effect/Cause").YieldableError>;
148
+ declare class InternalServerError extends InternalServerError_base {}
149
+ //#endregion
150
+ export { NotFound as a, action as c, InternalServerError as i, endpoint as l, Conflict as n, Unauthorized as o, Forbidden as r, errors_d_exports as s, BadRequest as t };
151
+ //# sourceMappingURL=errors.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/native/contracts.ts","../../src/native/errors.ts"],"mappings":";;;;;;cAoBa,eACL,kBACN,UAAU,OAAO,KACjB,UAAU,OAAO,WACX,wBAAwB,OAAO,OAErC,MAAM,GACN,oBACA;EACE,OAAO;EACP,QAAQ;EACR,QAAQ;EACR;EACA;EACA;EACA;aACW;aACA;aACA;aACA;;QAkDM,gBAAgB,wBAAwB,GAAC,UAChD,OAAO,cAAc,OAAO,OAAO,WAAW,SAAS,OAAE;EAE5C,UAAA,OAAA,cAAS,OAAA,OAAA,WAAA,SAAA,QAAA,2BAAA;EAKH,gBAAA;IAAE,SAAS;QAAW,OAAA,OAAA,WAAA,SAAA,QAAA,2BAAA;;;EAnBjC,QAAA;;;;;;;;;;;;;EAAA,QAAA;;;;;;;;;;;KA8BjB;KACA,KAAK,GAAG,UAAU,gBAAgB,gBAAgB,IAAI,EAAE;KAExD,WAAW,MAAM,6BAElB,UAAU,OAAO,MACf,OAAO,kBAAkB;KAG1B,aAAa,MAAM,6BAEpB,UAAU,OAAO,MACf,OAAO,YAAY;KAGpB,aAAa,MAAM,4BACb,cAAc,YACrB,UAAU,OAAO,MACf,OAAO,YAAY;KAGpB,WAAW,mBAAmB,OAAO,UAAU,6BAEhD,OAAO,YAAY,OAAO,OAAO,OAAO,MAAM;;cAGrC,iBACL,wBACA,UAAU,kBACV,UAAU,eAAe,OAAO,MACtC,UAAU,OAAO,WACX,wBAAwB,OAAO,OAErC,MAAM,GACN,QAAQ,GACR,oBACA;WACW,OAAO,IACd,OAAO,cAAc,GAAG,yBACvB,UAAU,WAAW;aAAoB;;WACnC,QAAQ;WACR,QAAQ;WACR;WACA;WACA;QAuDQ,gBAAgB,wBAAwB,GAAC,UAExD,OAAK,OAAA,OAAA,KAAA,IAAA,OAAA,cAAA,GAAA,yBAAA,UAAA,WAAA;WA9D+C;;WAAA;;WAAA;mBA+DjD,OAAO,OAAO,WAAW,SAAS,OAAE;EAKrB,QAAA;;;aApEkC;;aAAA;;aAAA;;;aAAA;;aAAA;;aAAA;;;;;aAAA;;;;eAAA;;;;;;;;;EAyDpC,QAAA;;;;aAzDoC;;;;eAAA;;;;;;;;;;;;;;cCjJ7C,mBAAmB;;;;cAKnB,qBAAqB;;;;cAKrB,kBAAkB;;;;cAKlB,iBAAiB;;;;cAKjB,iBAAiB;;;;cAKjB,4BAA4B"}
@@ -0,0 +1,132 @@
1
+ import { t as __exportAll } from "./rolldown-runtime.js";
2
+ import { Effect, Schema, SchemaAST, SchemaGetter } from "effect";
3
+ import { HttpApiEndpoint, OpenApi } from "effect/http-api";
4
+ import { Rpc } from "effect/rpc";
5
+ import { Tool } from "effect/ai";
6
+ //#region src/native/contracts.ts
7
+ const redactedDefect = Schema.Unknown.pipe(Schema.decodeTo(Schema.Unknown, {
8
+ decode: SchemaGetter.transform(() => /* @__PURE__ */ new Error("Internal server error")),
9
+ encode: SchemaGetter.transform(() => ({ message: "Internal server error" }))
10
+ }));
11
+ const errorWrapper = (error) => Schema.Union([error]).annotate({ httpApiStatus: SchemaAST.resolveAt("httpApiStatus")(error.ast) ?? 500 });
12
+ const action = (name, path, schemas) => {
13
+ const errors = schemas.errors.map((error) => errorWrapper(error));
14
+ HttpApiEndpoint.post(name, path, {
15
+ payload: schemas.input,
16
+ success: schemas.output,
17
+ error: Schema.Union([Schema.Union(schemas.errors)])
18
+ });
19
+ let endpoint = HttpApiEndpoint.post(name, path, {
20
+ payload: schemas.input,
21
+ success: schemas.output,
22
+ error: errors
23
+ });
24
+ if (schemas.description) endpoint = endpoint.annotate(OpenApi.Description, schemas.description);
25
+ if (schemas.title) endpoint = endpoint.annotate(OpenApi.Summary, schemas.title);
26
+ let tool = Tool.make(name, {
27
+ parameters: schemas.input,
28
+ success: schemas.output,
29
+ failure: Schema.Union(schemas.errors),
30
+ description: schemas.description
31
+ });
32
+ if (schemas.title) tool = tool.annotate(Tool.Title, schemas.title);
33
+ if (schemas.tool?.readOnly !== void 0) tool = tool.annotate(Tool.Readonly, schemas.tool.readOnly);
34
+ if (schemas.tool?.destructive !== void 0) tool = tool.annotate(Tool.Destructive, schemas.tool.destructive);
35
+ if (schemas.tool?.idempotent !== void 0) tool = tool.annotate(Tool.Idempotent, schemas.tool.idempotent);
36
+ if (schemas.tool?.openWorld !== void 0) tool = tool.annotate(Tool.OpenWorld, schemas.tool.openWorld);
37
+ const contract = Object.freeze({
38
+ name,
39
+ endpoint,
40
+ method: "POST",
41
+ path,
42
+ rpc: Rpc.make(name, {
43
+ payload: schemas.input,
44
+ success: schemas.output,
45
+ error: Schema.Union(schemas.errors),
46
+ defect: redactedDefect
47
+ }),
48
+ tool,
49
+ mcp: schemas.mcp === true
50
+ });
51
+ const implement = (handler) => {
52
+ const invoke = (input) => handler(input).pipe(Effect.withSpan(`brick.action.${name}`));
53
+ return Object.freeze({
54
+ ...contract,
55
+ handler: invoke,
56
+ httpHandler: ({ payload }) => invoke(payload)
57
+ });
58
+ };
59
+ Object.defineProperty(implement, "name", {
60
+ value: name,
61
+ writable: true,
62
+ configurable: true
63
+ });
64
+ return Object.freeze(Object.assign(implement, contract));
65
+ };
66
+ /** Typed HTTP request parts also form the input contract for local/RPC/tool calls. */
67
+ const endpoint = (name, method, path, schemas) => {
68
+ const requestSchema = Schema.Struct(schemas.input);
69
+ const base = action(name, path, {
70
+ ...schemas,
71
+ input: requestSchema
72
+ });
73
+ const parts = schemas.input;
74
+ const endpointOptions = {
75
+ ...parts.params !== void 0 ? { params: parts.params } : {},
76
+ ...parts.query !== void 0 ? { query: parts.query } : {},
77
+ ...parts.payload !== void 0 ? { payload: parts.payload } : {},
78
+ ...parts.headers !== void 0 ? { headers: parts.headers } : {},
79
+ success: schemas.output,
80
+ error: Schema.Union([Schema.Union(schemas.errors)])
81
+ };
82
+ HttpApiEndpoint.make(method)(name, path, endpointOptions);
83
+ const http = HttpApiEndpoint.make(method)(name, path, {
84
+ ...parts.params !== void 0 ? { params: parts.params } : {},
85
+ ...parts.query !== void 0 ? { query: parts.query } : {},
86
+ ...parts.payload !== void 0 ? { payload: parts.payload } : {},
87
+ ...parts.headers !== void 0 ? { headers: parts.headers } : {},
88
+ success: schemas.output,
89
+ error: schemas.errors.map(errorWrapper)
90
+ });
91
+ const metadata = {
92
+ ...base,
93
+ name,
94
+ method,
95
+ endpoint: http
96
+ };
97
+ const implement = (handler) => {
98
+ const implemented = base(handler);
99
+ return Object.freeze({
100
+ ...implemented,
101
+ method,
102
+ endpoint: http,
103
+ httpHandler: implemented.handler
104
+ });
105
+ };
106
+ Object.defineProperty(implement, "name", {
107
+ value: name,
108
+ writable: true,
109
+ configurable: true
110
+ });
111
+ return Object.freeze(Object.assign(implement, metadata));
112
+ };
113
+ //#endregion
114
+ //#region src/native/errors.ts
115
+ var errors_exports = /* @__PURE__ */ __exportAll({
116
+ BadRequest: () => BadRequest,
117
+ Conflict: () => Conflict,
118
+ Forbidden: () => Forbidden,
119
+ InternalServerError: () => InternalServerError,
120
+ NotFound: () => NotFound,
121
+ Unauthorized: () => Unauthorized
122
+ });
123
+ var BadRequest = class extends Schema.TaggedError()("BadRequest", { message: Schema.String }, { httpApiStatus: 400 }) {};
124
+ var Unauthorized = class extends Schema.TaggedError()("Unauthorized", { message: Schema.String }, { httpApiStatus: 401 }) {};
125
+ var Forbidden = class extends Schema.TaggedError()("Forbidden", { message: Schema.String }, { httpApiStatus: 403 }) {};
126
+ var NotFound = class extends Schema.TaggedError()("NotFound", { message: Schema.String }, { httpApiStatus: 404 }) {};
127
+ var Conflict = class extends Schema.TaggedError()("Conflict", { message: Schema.String }, { httpApiStatus: 409 }) {};
128
+ var InternalServerError = class extends Schema.TaggedError()("InternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {};
129
+ //#endregion
130
+ export { NotFound as a, action as c, InternalServerError as i, endpoint as l, Conflict as n, Unauthorized as o, Forbidden as r, errors_exports as s, BadRequest as t };
131
+
132
+ //# sourceMappingURL=errors.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"errors.js","names":[],"sources":["../../src/native/contracts.ts","../../src/native/errors.ts"],"sourcesContent":["import { Effect, Schema, SchemaAST, SchemaGetter } from \"effect\";\nimport { HttpApiEndpoint, HttpApiSchema, OpenApi } from \"effect/http-api\";\nimport { Rpc } from \"effect/rpc\";\nimport { Tool } from \"effect/ai\";\nimport type { HttpMethod } from \"effect/http/HttpMethod\";\n\nconst redactedDefect = Schema.Unknown.pipe(\n Schema.decodeTo(Schema.Unknown, {\n decode: SchemaGetter.transform(() => new Error(\"Internal server error\")),\n encode: SchemaGetter.transform(() => ({\n message: \"Internal server error\",\n })),\n }),\n);\n\nconst errorWrapper = <E extends Schema.Top>(error: E) =>\n Schema.Union([error]).annotate({\n httpApiStatus:\n SchemaAST.resolveAt<number>(\"httpApiStatus\")(error.ast) ?? 500,\n });\nexport const action = <\n const N extends string,\n I extends Schema.Top,\n O extends Schema.Top,\n const Errors extends readonly Schema.Top[],\n>(\n name: N,\n path: `/${string}`,\n schemas: {\n input: I;\n output: O;\n errors: Errors;\n mcp?: boolean;\n description?: string;\n title?: string;\n tool?: {\n readonly readOnly?: boolean;\n readonly destructive?: boolean;\n readonly idempotent?: boolean;\n readonly openWorld?: boolean;\n };\n },\n) => {\n const errors = schemas.errors.map((error) => errorWrapper(error));\n const typedEndpoint = HttpApiEndpoint.post(name, path, {\n payload: schemas.input,\n success: schemas.output,\n error: Schema.Union([Schema.Union(schemas.errors)]),\n });\n // Native private ErrorNoStream cannot reduce arrays with open schema members.\n // Mapping the identical error schemas preserves all Type/EncodingServices slots.\n let endpoint = HttpApiEndpoint.post(name, path, {\n payload: schemas.input,\n success: schemas.output,\n error: errors,\n }) as unknown as typeof typedEndpoint;\n if (schemas.description)\n endpoint = endpoint.annotate(OpenApi.Description, schemas.description);\n if (schemas.title)\n endpoint = endpoint.annotate(OpenApi.Summary, schemas.title);\n let tool = Tool.make(name, {\n parameters: schemas.input,\n success: schemas.output,\n failure: Schema.Union(schemas.errors),\n description: schemas.description,\n });\n if (schemas.title) tool = tool.annotate(Tool.Title, schemas.title);\n if (schemas.tool?.readOnly !== undefined)\n tool = tool.annotate(Tool.Readonly, schemas.tool.readOnly);\n if (schemas.tool?.destructive !== undefined)\n tool = tool.annotate(Tool.Destructive, schemas.tool.destructive);\n if (schemas.tool?.idempotent !== undefined)\n tool = tool.annotate(Tool.Idempotent, schemas.tool.idempotent);\n if (schemas.tool?.openWorld !== undefined)\n tool = tool.annotate(Tool.OpenWorld, schemas.tool.openWorld);\n const contract = Object.freeze({\n name,\n endpoint,\n method: \"POST\" as HttpMethod,\n path,\n rpc: Rpc.make(name, {\n payload: schemas.input,\n success: schemas.output,\n error: Schema.Union(schemas.errors),\n defect: redactedDefect,\n }),\n tool,\n mcp: schemas.mcp === true,\n });\n const implement = <Failure extends Errors[number][\"Type\"], R>(\n handler: (input: I[\"Type\"]) => Effect.Effect<O[\"Type\"], Failure, R>,\n ) => {\n const invoke = (input: I[\"Type\"]) =>\n handler(input).pipe(Effect.withSpan(`brick.action.${name}`));\n return Object.freeze({\n ...contract,\n handler: invoke,\n httpHandler: ({ payload }: { payload: I[\"Type\"] }) => invoke(payload),\n });\n };\n Object.defineProperty(implement, \"name\", {\n value: name,\n writable: true,\n configurable: true,\n });\n return Object.freeze(Object.assign(implement, contract));\n};\n\ntype HttpInputKey = \"params\" | \"query\" | \"payload\" | \"headers\";\ntype Part<I, K extends HttpInputKey> = K extends keyof I ? I[K] : never;\n\ntype ParamCodec<S> = [S] extends [never]\n ? never\n : S extends Schema.Top\n ? Schema.toCodecStringTree<S>\n : never;\n\ntype PayloadCodec<S> = [S] extends [never]\n ? never\n : S extends Schema.Top\n ? Schema.toCodecJson<S>\n : never;\n\ntype SuccessCodec<S> = [S] extends [never]\n ? typeof HttpApiSchema.NoContent\n : S extends Schema.Top\n ? Schema.toCodecJson<S>\n : never;\n\ntype ErrorCodec<E extends readonly Schema.Top[]> = [E] extends [never]\n ? never\n : Schema.toCodecJson<Schema.Union<[Schema.Union<E>]>>;\n\n/** Typed HTTP request parts also form the input contract for local/RPC/tool calls. */\nexport const endpoint = <\n const N extends string,\n const M extends HttpMethod,\n const I extends Record<string, Schema.Top>,\n O extends Schema.Top,\n const Errors extends readonly Schema.Top[],\n>(\n name: N,\n method: M,\n path: `/${string}`,\n schemas: {\n readonly input: I &\n Record<Exclude<keyof I, HttpInputKey>, never> &\n (M extends HttpMethod.NoBody ? { readonly payload?: never } : unknown);\n readonly output: O;\n readonly errors: Errors;\n readonly mcp?: boolean;\n readonly description?: string;\n readonly title?: string;\n },\n) => {\n const requestSchema = Schema.Struct(schemas.input);\n const base = action(name, path, { ...schemas, input: requestSchema });\n const parts = schemas.input;\n const endpointOptions = {\n ...(parts.params !== undefined\n ? { params: parts.params as Part<I, \"params\"> }\n : {}),\n ...(parts.query !== undefined\n ? { query: parts.query as Part<I, \"query\"> }\n : {}),\n ...(parts.payload !== undefined\n ? {\n payload: parts.payload as Part<I, \"payload\"> &\n HttpApiEndpoint.PayloadConstraintCodecs<M>,\n }\n : {}),\n ...(parts.headers !== undefined\n ? { headers: parts.headers as Part<I, \"headers\"> }\n : {}),\n success: schemas.output,\n error: Schema.Union([Schema.Union(schemas.errors)]),\n };\n const typed = (HttpApiEndpoint.make(method) as any)(\n name,\n path,\n endpointOptions,\n ) as HttpApiEndpoint.HttpApiEndpoint<\n N,\n M,\n `/${string}`,\n ParamCodec<Part<I, \"params\">>,\n ParamCodec<Part<I, \"query\">>,\n PayloadCodec<Part<I, \"payload\">>,\n ParamCodec<Part<I, \"headers\">>,\n SuccessCodec<O>,\n ErrorCodec<Errors>\n >;\n\n const http = (HttpApiEndpoint.make(method) as any)(name, path, {\n ...(parts.params !== undefined ? { params: parts.params } : {}),\n ...(parts.query !== undefined ? { query: parts.query } : {}),\n ...(parts.payload !== undefined ? { payload: parts.payload } : {}),\n ...(parts.headers !== undefined ? { headers: parts.headers } : {}),\n success: schemas.output,\n error: schemas.errors.map(errorWrapper),\n }) as unknown as typeof typed;\n const metadata = {\n ...base,\n name,\n method: method as HttpMethod,\n endpoint: http,\n };\n const implement = <Failure extends Errors[number][\"Type\"], R>(\n handler: (\n input: typeof requestSchema.Type,\n ) => Effect.Effect<O[\"Type\"], Failure, R>,\n ) => {\n const implemented = base(handler);\n return Object.freeze({\n ...implemented,\n method: method as HttpMethod,\n endpoint: http,\n httpHandler: implemented.handler,\n });\n };\n Object.defineProperty(implement, \"name\", {\n value: name,\n writable: true,\n configurable: true,\n });\n return Object.freeze(Object.assign(implement, metadata));\n};\n","import { Schema } from \"effect\";\n\nexport class BadRequest extends Schema.TaggedError<BadRequest>()(\n \"BadRequest\",\n { message: Schema.String },\n { httpApiStatus: 400 },\n) {}\nexport class Unauthorized extends Schema.TaggedError<Unauthorized>()(\n \"Unauthorized\",\n { message: Schema.String },\n { httpApiStatus: 401 },\n) {}\nexport class Forbidden extends Schema.TaggedError<Forbidden>()(\n \"Forbidden\",\n { message: Schema.String },\n { httpApiStatus: 403 },\n) {}\nexport class NotFound extends Schema.TaggedError<NotFound>()(\n \"NotFound\",\n { message: Schema.String },\n { httpApiStatus: 404 },\n) {}\nexport class Conflict extends Schema.TaggedError<Conflict>()(\n \"Conflict\",\n { message: Schema.String },\n { httpApiStatus: 409 },\n) {}\nexport class InternalServerError extends Schema.TaggedError<InternalServerError>()(\n \"InternalServerError\",\n { message: Schema.String },\n { httpApiStatus: 500 },\n) {}\n"],"mappings":"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"}
@@ -0,0 +1,13 @@
1
+ //#region \0rolldown/runtime.js
2
+ var __defProp = Object.defineProperty;
3
+ var __exportAll = (all, no_symbols) => {
4
+ let target = {};
5
+ for (var name in all) __defProp(target, name, {
6
+ get: all[name],
7
+ enumerable: true
8
+ });
9
+ if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
10
+ return target;
11
+ };
12
+ //#endregion
13
+ export { __exportAll as t };
@@ -0,0 +1,2 @@
1
+ import { a as NotFound, c as action, i as InternalServerError, l as endpoint, n as Conflict, o as Unauthorized, r as Forbidden, t as BadRequest } from "./chunks/errors.js";
2
+ export { BadRequest, Conflict, Forbidden, InternalServerError, NotFound, Unauthorized, action, endpoint };
@@ -0,0 +1 @@
1
+ export { t as BadRequest, n as Conflict, r as Forbidden, i as InternalServerError, a as NotFound, o as Unauthorized, c as action, l as endpoint } from "./chunks/errors.js";