@brickkit/core 0.4.2 → 0.5.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 +73 -91
- package/dist/chunks/errors.d.ts +151 -0
- package/dist/chunks/errors.d.ts.map +1 -0
- package/dist/chunks/errors.js +132 -0
- package/dist/chunks/errors.js.map +1 -0
- package/dist/chunks/rolldown-runtime.js +13 -0
- package/dist/contracts.d.ts +2 -0
- package/dist/contracts.js +1 -0
- package/dist/index.d.ts +295 -441
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +204 -2389
- package/dist/index.js.map +1 -1
- package/dist/pg.d.ts +4 -4
- package/dist/pg.d.ts.map +1 -1
- package/dist/pg.js +2 -2
- package/package.json +10 -8
- package/dist/chunks/client.d.ts +0 -897
- package/dist/chunks/client.d.ts.map +0 -1
- package/dist/chunks/client.js +0 -247
- package/dist/chunks/client.js.map +0 -1
- package/dist/client.d.ts +0 -2
- package/dist/client.js +0 -1
package/README.md
CHANGED
|
@@ -1,118 +1,100 @@
|
|
|
1
1
|
# @brickkit/core
|
|
2
2
|
|
|
3
|
-
|
|
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 {
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
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
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
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
|
-
|
|
25
|
+
const users = Brick.service("users", { actions: { getUser } });
|
|
26
|
+
export const app = Brick.app({ services: [users], layer: Layer.empty });
|
|
42
27
|
|
|
43
|
-
|
|
44
|
-
bun add @brickkit/core drizzle-orm postgres
|
|
28
|
+
Bun.serve({ port: 3000, fetch: app.fetch });
|
|
45
29
|
```
|
|
46
30
|
|
|
47
|
-
|
|
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
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
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
|
-
|
|
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
|
-
|
|
47
|
+
## Typed errors
|
|
66
48
|
|
|
67
|
-
|
|
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
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
55
|
+
export class SlugTaken extends Schema.TaggedError<SlugTaken>()(
|
|
56
|
+
"SlugTaken",
|
|
57
|
+
{ slug: Schema.String },
|
|
58
|
+
{ httpApiStatus: 409 },
|
|
59
|
+
) {}
|
|
75
60
|
```
|
|
76
61
|
|
|
77
|
-
|
|
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
|
-
##
|
|
65
|
+
## Dependencies
|
|
80
66
|
|
|
81
|
-
|
|
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
|
-
|
|
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
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
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
|
-
|
|
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
|
-
|
|
94
|
+
## Entry points
|
|
117
95
|
|
|
118
|
-
|
|
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";
|