@brickkit/core 0.9.1 → 0.10.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/dist/chunks/client.d.ts +105 -2
- package/dist/chunks/client.d.ts.map +1 -1
- package/dist/chunks/client.js +221 -1
- package/dist/chunks/client.js.map +1 -1
- package/dist/client.d.ts +2 -2
- package/dist/client.js +1 -1
- package/dist/index.d.ts +17 -2
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +245 -2
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { a as isBrickTransportError, i as isBrickServerError,
|
|
1
|
+
import { a as isBrickTransportError, c as SOCKET_MAX_BYTES, d as ActionExecutionError, f as ValidationError, i as isBrickServerError, l as isSocketEnvelope, n as BrickTransportError, r as createBrickClient, s as SOCKET_BUFFER_BYTES, t as BrickServerError, u as serializeSocketSchema } from "./chunks/client.js";
|
|
2
2
|
import { createRequire } from "node:module";
|
|
3
3
|
import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
|
|
4
4
|
import { Type, Type as t } from "@sinclair/typebox";
|
|
@@ -12,6 +12,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
|
|
|
12
12
|
import { existsSync, mkdirSync, readFileSync } from "node:fs";
|
|
13
13
|
import { dirname, join, resolve } from "node:path";
|
|
14
14
|
import { pathToFileURL } from "node:url";
|
|
15
|
+
import { websocket } from "elysia/websocket";
|
|
15
16
|
import postgres from "postgres";
|
|
16
17
|
import { drizzle } from "drizzle-orm/postgres-js";
|
|
17
18
|
//#region \0rolldown/runtime.js
|
|
@@ -174,6 +175,7 @@ var ServiceRegistry = class {
|
|
|
174
175
|
const schema = service.introspect();
|
|
175
176
|
return {
|
|
176
177
|
...schema,
|
|
178
|
+
...application?.sockets ? { sockets: application.sockets.filter((socket) => socket.service === service.name) } : {},
|
|
177
179
|
actions: schema.actions.map((action) => {
|
|
178
180
|
const route = byAction.get(action.name);
|
|
179
181
|
return route ? {
|
|
@@ -3083,6 +3085,217 @@ var EventsHub = class {
|
|
|
3083
3085
|
}
|
|
3084
3086
|
};
|
|
3085
3087
|
//#endregion
|
|
3088
|
+
//#region src/socket.ts
|
|
3089
|
+
var SocketDenied = class extends Error {};
|
|
3090
|
+
function defineServiceSocket(config, resolve) {
|
|
3091
|
+
if (!config.name || config.name.split(".").some((part) => !/^[a-zA-Z_][\w-]*$/.test(part))) throw new Error("Invalid socket name");
|
|
3092
|
+
if (config.path !== void 0 && (!config.path.startsWith("/") || /[?#*]/.test(config.path) || config.path.split("/").some((segment) => segment.startsWith(":")))) throw new Error("Socket path must be a static absolute route without a query or fragment");
|
|
3093
|
+
const input = Object.freeze({ ...config.input });
|
|
3094
|
+
const output = Object.freeze({ ...config.output });
|
|
3095
|
+
const handlers = { ...config.handlers };
|
|
3096
|
+
if (Object.keys(input).length !== Object.keys(handlers).length || Object.keys(input).some((key) => !Object.hasOwn(handlers, key) || typeof handlers[key] !== "function")) throw new Error("Every socket input event needs exactly one handler");
|
|
3097
|
+
for (const schema of [...Object.values(input), ...Object.values(output)]) {
|
|
3098
|
+
serializeSocketSchema(schema);
|
|
3099
|
+
getCompiledCheck(schema);
|
|
3100
|
+
}
|
|
3101
|
+
const typed = (socket) => socket;
|
|
3102
|
+
const context = async (request) => {
|
|
3103
|
+
const ctx = await resolve(request);
|
|
3104
|
+
if (config.authorize && !await config.authorize({ ctx })) throw new SocketDenied();
|
|
3105
|
+
return ctx;
|
|
3106
|
+
};
|
|
3107
|
+
return {
|
|
3108
|
+
schema: {
|
|
3109
|
+
name: config.name,
|
|
3110
|
+
path: config.path,
|
|
3111
|
+
description: config.description,
|
|
3112
|
+
input: Object.keys(input),
|
|
3113
|
+
output: Object.keys(output),
|
|
3114
|
+
hasAuthorize: !!config.authorize
|
|
3115
|
+
},
|
|
3116
|
+
input,
|
|
3117
|
+
output,
|
|
3118
|
+
allowedOrigins: config.allowedOrigins ? [...config.allowedOrigins] : void 0,
|
|
3119
|
+
allowMissingOrigin: config.allowMissingOrigin,
|
|
3120
|
+
async connect(request) {
|
|
3121
|
+
const initial = await context(request);
|
|
3122
|
+
return {
|
|
3123
|
+
async open(socket) {
|
|
3124
|
+
await config.open?.({
|
|
3125
|
+
ctx: initial,
|
|
3126
|
+
socket: typed(socket)
|
|
3127
|
+
});
|
|
3128
|
+
},
|
|
3129
|
+
async message(event, data, socket) {
|
|
3130
|
+
const schema = Object.hasOwn(input, event) ? input[event] : void 0;
|
|
3131
|
+
if (!schema || !getCompiledCheck(schema).Check(data)) throw new SocketDenied();
|
|
3132
|
+
const ctx = await context(request);
|
|
3133
|
+
if (!socket.isOpen) return;
|
|
3134
|
+
const handler = handlers[event];
|
|
3135
|
+
await handler({
|
|
3136
|
+
input: data,
|
|
3137
|
+
ctx,
|
|
3138
|
+
socket: typed(socket)
|
|
3139
|
+
});
|
|
3140
|
+
},
|
|
3141
|
+
async close(socket, code, reason) {
|
|
3142
|
+
await config.close?.({
|
|
3143
|
+
ctx: initial,
|
|
3144
|
+
socket: typed(socket),
|
|
3145
|
+
code,
|
|
3146
|
+
reason
|
|
3147
|
+
});
|
|
3148
|
+
}
|
|
3149
|
+
};
|
|
3150
|
+
}
|
|
3151
|
+
};
|
|
3152
|
+
}
|
|
3153
|
+
function socketPath(prefix, service, socket) {
|
|
3154
|
+
return socket.schema.path ?? `${prefix.replace(/\/$/, "")}/${service}/${socket.schema.name}`;
|
|
3155
|
+
}
|
|
3156
|
+
/** The origin a browser saw, so TLS-terminating proxies still pass the same-origin check. */
|
|
3157
|
+
function publicOrigin(request) {
|
|
3158
|
+
const forwarded = (name) => request.headers.get(name)?.split(",")[0]?.trim() || void 0;
|
|
3159
|
+
const url = new URL(request.url);
|
|
3160
|
+
const proto = forwarded("x-forwarded-proto");
|
|
3161
|
+
return `${proto ? `${proto}:` : url.protocol}//${forwarded("x-forwarded-host") ?? url.host}`;
|
|
3162
|
+
}
|
|
3163
|
+
/** Mounts native adapters. Each connection owns its queue and service session. */
|
|
3164
|
+
function mountSockets(app, sockets) {
|
|
3165
|
+
if (!sockets.length) return;
|
|
3166
|
+
app.use(websocket({
|
|
3167
|
+
maxPayloadLength: SOCKET_MAX_BYTES,
|
|
3168
|
+
backpressureLimit: SOCKET_BUFFER_BYTES,
|
|
3169
|
+
closeOnBackpressureLimit: true
|
|
3170
|
+
}));
|
|
3171
|
+
for (const { service, path, definition } of sockets) {
|
|
3172
|
+
const logger = createLogger(`[Brick socket ${service}.${definition.schema.name}]`);
|
|
3173
|
+
const sessions = /* @__PURE__ */ new WeakMap();
|
|
3174
|
+
const connections = /* @__PURE__ */ new WeakMap();
|
|
3175
|
+
const fail = (ws, error) => {
|
|
3176
|
+
if (!(error instanceof SocketDenied)) logger.error({
|
|
3177
|
+
error,
|
|
3178
|
+
service,
|
|
3179
|
+
socket: definition.schema.name
|
|
3180
|
+
});
|
|
3181
|
+
if (ws.readyState !== 1) return;
|
|
3182
|
+
ws.close(error instanceof SocketDenied ? 1008 : 1011, error instanceof SocketDenied ? "Message refused" : "Socket handler failed");
|
|
3183
|
+
};
|
|
3184
|
+
app.ws(path, {
|
|
3185
|
+
async beforeHandle({ request }) {
|
|
3186
|
+
if (sessions.has(request)) return;
|
|
3187
|
+
const origin = request.headers.get("origin");
|
|
3188
|
+
if (origin ? !(definition.allowedOrigins ?? [publicOrigin(request)]).includes(origin) : !definition.allowMissingOrigin) return new Response("Socket origin refused", { status: 403 });
|
|
3189
|
+
try {
|
|
3190
|
+
sessions.set(request, await definition.connect(request));
|
|
3191
|
+
} catch (error) {
|
|
3192
|
+
if (!(error instanceof SocketDenied)) logger.error({
|
|
3193
|
+
error,
|
|
3194
|
+
service,
|
|
3195
|
+
socket: definition.schema.name
|
|
3196
|
+
});
|
|
3197
|
+
return new Response("Socket connection refused", { status: error instanceof SocketDenied ? 403 : 500 });
|
|
3198
|
+
}
|
|
3199
|
+
},
|
|
3200
|
+
async open(ws) {
|
|
3201
|
+
const session = sessions.get(ws.request);
|
|
3202
|
+
if (!session) {
|
|
3203
|
+
ws.close(1011, "Missing socket session");
|
|
3204
|
+
return;
|
|
3205
|
+
}
|
|
3206
|
+
const sender = {
|
|
3207
|
+
get isOpen() {
|
|
3208
|
+
return !state.closed && ws.readyState === 1;
|
|
3209
|
+
},
|
|
3210
|
+
close() {
|
|
3211
|
+
ws.close(1e3, "");
|
|
3212
|
+
},
|
|
3213
|
+
send(event, data) {
|
|
3214
|
+
if (!sender.isOpen) throw new Error("Socket is closed");
|
|
3215
|
+
const schema = Object.hasOwn(definition.output, event) ? definition.output[event] : void 0;
|
|
3216
|
+
if (!schema || !getCompiledCheck(schema).Check(data)) throw new Error("Invalid socket output");
|
|
3217
|
+
const frame = JSON.stringify({
|
|
3218
|
+
event,
|
|
3219
|
+
data
|
|
3220
|
+
});
|
|
3221
|
+
if (new TextEncoder().encode(frame).byteLength > 65536) throw new Error("Socket output too large");
|
|
3222
|
+
if (!getCompiledCheck(schema).Check(JSON.parse(frame).data)) throw new Error("Socket output is not JSON-compatible");
|
|
3223
|
+
if (ws.send(frame) === 0) {
|
|
3224
|
+
ws.close(1013, "Socket buffer full");
|
|
3225
|
+
throw new Error("Socket buffer full");
|
|
3226
|
+
}
|
|
3227
|
+
}
|
|
3228
|
+
};
|
|
3229
|
+
const state = {
|
|
3230
|
+
session,
|
|
3231
|
+
sender,
|
|
3232
|
+
tail: Promise.resolve(),
|
|
3233
|
+
pending: 0,
|
|
3234
|
+
bytes: 0,
|
|
3235
|
+
closed: false
|
|
3236
|
+
};
|
|
3237
|
+
connections.set(ws.request, state);
|
|
3238
|
+
try {
|
|
3239
|
+
await session.open(sender);
|
|
3240
|
+
} catch (error) {
|
|
3241
|
+
fail(ws, error);
|
|
3242
|
+
}
|
|
3243
|
+
},
|
|
3244
|
+
message(ws, value) {
|
|
3245
|
+
const state = connections.get(ws.request);
|
|
3246
|
+
if (!state || state.closed || ws.readyState !== 1) return;
|
|
3247
|
+
if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
|
|
3248
|
+
ws.close(1003, "Only JSON text is supported");
|
|
3249
|
+
return;
|
|
3250
|
+
}
|
|
3251
|
+
if (typeof value === "string") {
|
|
3252
|
+
ws.close(1007, "Expected JSON envelope");
|
|
3253
|
+
return;
|
|
3254
|
+
}
|
|
3255
|
+
if (!isSocketEnvelope(value)) {
|
|
3256
|
+
ws.close(1008, "Invalid socket envelope");
|
|
3257
|
+
return;
|
|
3258
|
+
}
|
|
3259
|
+
const size = new TextEncoder().encode(JSON.stringify(value)).byteLength;
|
|
3260
|
+
if (size > 65536) {
|
|
3261
|
+
ws.close(1009, "Message too large");
|
|
3262
|
+
return;
|
|
3263
|
+
}
|
|
3264
|
+
if (state.pending >= 32 || state.bytes + size > 1048576) {
|
|
3265
|
+
ws.close(1013, "Socket queue full");
|
|
3266
|
+
return;
|
|
3267
|
+
}
|
|
3268
|
+
state.pending++;
|
|
3269
|
+
state.bytes += size;
|
|
3270
|
+
state.tail = state.tail.then(async () => {
|
|
3271
|
+
if (state.closed || ws.readyState !== 1) return;
|
|
3272
|
+
await state.session.message(value.event, value.data, state.sender);
|
|
3273
|
+
}).catch((error) => fail(ws, error)).finally(() => {
|
|
3274
|
+
state.pending--;
|
|
3275
|
+
state.bytes -= size;
|
|
3276
|
+
});
|
|
3277
|
+
},
|
|
3278
|
+
async close(ws, code = 1006, reason = "") {
|
|
3279
|
+
const state = connections.get(ws.request);
|
|
3280
|
+
sessions.delete(ws.request);
|
|
3281
|
+
if (!state || state.closed) return;
|
|
3282
|
+
state.closed = true;
|
|
3283
|
+
try {
|
|
3284
|
+
await state.session.close(state.sender, code, reason);
|
|
3285
|
+
} catch (error) {
|
|
3286
|
+
logger.error({
|
|
3287
|
+
error,
|
|
3288
|
+
service,
|
|
3289
|
+
socket: definition.schema.name,
|
|
3290
|
+
phase: "cleanup"
|
|
3291
|
+
});
|
|
3292
|
+
}
|
|
3293
|
+
connections.delete(ws.request);
|
|
3294
|
+
}
|
|
3295
|
+
});
|
|
3296
|
+
}
|
|
3297
|
+
}
|
|
3298
|
+
//#endregion
|
|
3086
3299
|
//#region src/server.ts
|
|
3087
3300
|
/**
|
|
3088
3301
|
* Create the HTTP application: an Elysia app that serves every service's
|
|
@@ -3199,8 +3412,20 @@ function brick(options = {}) {
|
|
|
3199
3412
|
swaggerPath
|
|
3200
3413
|
]) registeredRoutes.set(routeKey("GET", path), false);
|
|
3201
3414
|
if (referencePath !== void 0) registeredRoutes.set(routeKey("GET", referencePath), false);
|
|
3415
|
+
const sockets = services.flatMap((service) => service.listSockets().map((definition) => ({
|
|
3416
|
+
service: service.name,
|
|
3417
|
+
path: socketPath(prefix, service.name, definition),
|
|
3418
|
+
definition
|
|
3419
|
+
})));
|
|
3420
|
+
const socketRoutes = /* @__PURE__ */ new Set();
|
|
3421
|
+
for (const socket of sockets) {
|
|
3422
|
+
const key = routeKey("GET", socket.path);
|
|
3423
|
+
if (registeredRoutes.has(key) || socketRoutes.has(key)) throw new Error(`Brick: duplicate socket route '${socket.path}'`);
|
|
3424
|
+
socketRoutes.add(key);
|
|
3425
|
+
}
|
|
3202
3426
|
const mountRoute = (method, path, handler, plugin = false) => {
|
|
3203
3427
|
const key = routeKey(method, path);
|
|
3428
|
+
if (socketRoutes.has(key)) throw new Error(`Brick: route '${method} ${path}' conflicts with a socket`);
|
|
3204
3429
|
if (registeredRoutes.has(key)) {
|
|
3205
3430
|
if (plugin || registeredRoutes.get(key)) throw new Error(`Brick: duplicate plugin route '${method} ${path}'`);
|
|
3206
3431
|
return false;
|
|
@@ -3270,10 +3495,16 @@ function brick(options = {}) {
|
|
|
3270
3495
|
};
|
|
3271
3496
|
if (mountRoute(route.ir.method, route.ir.path, telemetry ? (context) => traceHttpRequest(context, route.ir.method, route.ir.path, () => invoke(context)) : invoke, getPluginActionRoute(action, prefix) !== void 0)) mountedRoutes.push(route.ir);
|
|
3272
3497
|
}
|
|
3498
|
+
mountSockets(app, sockets);
|
|
3273
3499
|
const definition = Object.freeze({
|
|
3274
3500
|
services: Object.freeze([...services]),
|
|
3275
3501
|
prefix,
|
|
3276
3502
|
routes: Object.freeze(mountedRoutes),
|
|
3503
|
+
sockets: Object.freeze(sockets.map(({ service, path, definition }) => ({
|
|
3504
|
+
...definition.schema,
|
|
3505
|
+
service,
|
|
3506
|
+
path
|
|
3507
|
+
}))),
|
|
3277
3508
|
telemetry,
|
|
3278
3509
|
documentation: normalizeDocumentation(options.documentation),
|
|
3279
3510
|
dashboard,
|
|
@@ -3805,6 +4036,7 @@ var ServiceImpl = class {
|
|
|
3805
4036
|
actions = /* @__PURE__ */ new Map();
|
|
3806
4037
|
tools = /* @__PURE__ */ new Map();
|
|
3807
4038
|
tables = /* @__PURE__ */ new Map();
|
|
4039
|
+
sockets = /* @__PURE__ */ new Map();
|
|
3808
4040
|
resources = /* @__PURE__ */ new Map();
|
|
3809
4041
|
preparations = /* @__PURE__ */ new Map();
|
|
3810
4042
|
database;
|
|
@@ -3897,6 +4129,16 @@ var ServiceImpl = class {
|
|
|
3897
4129
|
getTool(name) {
|
|
3898
4130
|
return this.tools.get(name);
|
|
3899
4131
|
}
|
|
4132
|
+
socket(config) {
|
|
4133
|
+
if (this._isBuilt) throw new Error("Sockets must be declared before service build");
|
|
4134
|
+
if (this.sockets.has(config.name)) throw new Error(`Duplicate socket: ${config.name}`);
|
|
4135
|
+
this.sockets.set(config.name, defineServiceSocket(config, (request) => resolveServiceContext(this, { request })));
|
|
4136
|
+
getGlobalRegistry().touch();
|
|
4137
|
+
return this;
|
|
4138
|
+
}
|
|
4139
|
+
listSockets() {
|
|
4140
|
+
return [...this.sockets.values()];
|
|
4141
|
+
}
|
|
3900
4142
|
listTools() {
|
|
3901
4143
|
return Array.from(this.tools.values());
|
|
3902
4144
|
}
|
|
@@ -3942,6 +4184,7 @@ var ServiceImpl = class {
|
|
|
3942
4184
|
name: this.name,
|
|
3943
4185
|
options,
|
|
3944
4186
|
hasDatabase: Boolean(this.database),
|
|
4187
|
+
sockets: this.listSockets().map((socket) => socket.schema),
|
|
3945
4188
|
databaseConfig,
|
|
3946
4189
|
actions: this.listActions().map((act) => {
|
|
3947
4190
|
const access = getActionAccess(act);
|
|
@@ -4313,6 +4556,6 @@ function createMcpHandler(options) {
|
|
|
4313
4556
|
};
|
|
4314
4557
|
}
|
|
4315
4558
|
//#endregion
|
|
4316
|
-
export { ACTION_ACCESS_KEY, ActionExecutionError, BrickServerError, BrickTransportError, Dispatcher, EventsHub, SecretRef, ServiceImpl, ServiceRegistry, Table, Type, UnknownToolError, ValidationError, and, asc, attachDatabase, bindCompiledApplication, blob, brick, buildErrorHelpers, buildFtsMatchQuery, compileBrickApplication, compileRoutePlan, compilerRuntime, createActionHandler, createBrickClient, createDatabase, createEndpointHandler, createMcpHandler, createMcpRegistry, createPostgresDatabase, createSQLiteDatabase, createServiceProxy, defineAction, defineDatabase, defineListener, defineResource, defineResourcePlugin, defineService, defineServicePlugin, defineTool, desc, emitEvent, emitHandlerFactory, endpointPaths, ensureResourceIndexes, ensureSQLiteFts, envSource, eq, executeCompiledRoute, foreignKey, generateOpenApiSpec, generateSQLiteIndexDdl, generateSQLiteTableDdl, getActionAccess, getCompiledCheck, getGlobalRegistry, getPluginActionRoute, getPluginEndpoints, getTableColumns, getTableName, gt, gte, hoistAnchoredSchemas, ilike, inArray, index, integer, is, isBrickApp, isBrickServerError, isBrickTransportError, isDatabaseHandle, isNotNull, isNull, isOutboxTable, isTool, like, listSecrets, loadCompiledBrickApp, lt, lte, ne, not, notInArray, onTransactionCommit, or, outboxTable, overrideSecret, overrideSecrets, primaryKey, real, referencePlugin, registerReferenceRoute, relations, requestLoggingPlugin, requireBrickApp, resetGlobalRegistry, resetSecrets, resolveEndpointDb, resolveSecrets, resolveWorkflowPaths, runInTransaction, scalarDocsHTML, secret, setActionAccess, sql, sqliteTable, stopAllEvents, swaggerDocsHTML, syncSchema, t, text, toErrorResponse, toOpenApiPath, traceRoute, uniqueIndex, validateWithSchema };
|
|
4559
|
+
export { ACTION_ACCESS_KEY, ActionExecutionError, BrickServerError, BrickTransportError, Dispatcher, EventsHub, SecretRef, ServiceImpl, ServiceRegistry, Table, Type, UnknownToolError, ValidationError, and, asc, attachDatabase, bindCompiledApplication, blob, brick, buildErrorHelpers, buildFtsMatchQuery, compileBrickApplication, compileRoutePlan, compilerRuntime, createActionHandler, createBrickClient, createDatabase, createEndpointHandler, createMcpHandler, createMcpRegistry, createPostgresDatabase, createSQLiteDatabase, createServiceProxy, defineAction, defineDatabase, defineListener, defineResource, defineResourcePlugin, defineService, defineServicePlugin, defineTool, desc, emitEvent, emitHandlerFactory, endpointPaths, ensureResourceIndexes, ensureSQLiteFts, envSource, eq, executeCompiledRoute, foreignKey, generateOpenApiSpec, generateSQLiteIndexDdl, generateSQLiteTableDdl, getActionAccess, getCompiledCheck, getGlobalRegistry, getPluginActionRoute, getPluginEndpoints, getTableColumns, getTableName, gt, gte, hoistAnchoredSchemas, ilike, inArray, index, integer, is, isBrickApp, isBrickServerError, isBrickTransportError, isDatabaseHandle, isNotNull, isNull, isOutboxTable, isTool, like, listSecrets, loadCompiledBrickApp, lt, lte, ne, not, notInArray, onTransactionCommit, or, outboxTable, overrideSecret, overrideSecrets, primaryKey, real, referencePlugin, registerReferenceRoute, relations, requestLoggingPlugin, requireBrickApp, resetGlobalRegistry, resetSecrets, resolveEndpointDb, resolveSecrets, resolveWorkflowPaths, runInTransaction, scalarDocsHTML, secret, serializeSocketSchema, setActionAccess, sql, sqliteTable, stopAllEvents, swaggerDocsHTML, syncSchema, t, text, toErrorResponse, toOpenApiPath, traceRoute, uniqueIndex, validateWithSchema };
|
|
4317
4560
|
|
|
4318
4561
|
//# sourceMappingURL=index.js.map
|