remult 3.3.15 → 3.3.17-next.0

package/SseSubscriptionServer.d.ts

@@ -1,8 +1,9 @@
 import type { GenericResponse } from './server/index.js';
+import type { SubscriptionServerRouteApi, SubscriptionServerWithRoutes } from './server/remult-api-server.js';
 import type { Remult } from './src/context.js';
-import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
-export declare class SseSubscriptionServer implements SubscriptionServer {
+export declare class SseSubscriptionServer implements SubscriptionServerWithRoutes {
     private canUserConnectToChannel?;
+    initApiServer(api: SubscriptionServerRouteApi): void;
     constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);
     publishMessage<T>(channel: string, message: any): Promise<void>;
 }

package/SseSubscriptionServer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientConnection = exports.SseSubscriptionServer = void 0;
 var tslib_1 = require("tslib");
 var SseSubscriptionClient_js_1 = require("./src/live-query/SseSubscriptionClient.js");
+var SubscriptionChannel_js_1 = require("./src/live-query/SubscriptionChannel.js");
 var SseSubscriptionServer = /** @class */ (function () {
     function SseSubscriptionServer(canUserConnectToChannel) {
         this.canUserConnectToChannel = canUserConnectToChannel;
@@ -16,6 +17,45 @@ var SseSubscriptionServer = /** @class */ (function () {
             this.canUserConnectToChannel = function () { return true; };
         }
     }
+    SseSubscriptionServer.prototype.initApiServer = function (api) {
+        var _this = this;
+        var streamPath = '/' + SubscriptionChannel_js_1.streamUrl;
+        api.addRoute(streamPath, 'get', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var req = _b.req, origRes = _b.origRes;
+            return tslib_1.__generator(this, function (_c) {
+                this.openHttpServerStream(req, origRes);
+                return [2 /*return*/];
+            });
+        }); });
+        api.addRoute(streamPath + '/subscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var _c;
+            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = this.subscribeToChannel;
+                        return [4 /*yield*/, getBody()];
+                    case 1:
+                        _c.apply(this, [_d.sent(), res, remult]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        api.addRoute(streamPath + '/unsubscribe', 'post', function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
+            var _c;
+            var remult = _b.remult, res = _b.res, getBody = _b.getBody;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = this.subscribeToChannel;
+                        return [4 /*yield*/, getBody()];
+                    case 1:
+                        _c.apply(this, [_d.sent(), res, remult, true]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
     //@internal
     SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
         var e_1, _b;

package/esm/SseSubscriptionServer.js

@@ -1,6 +1,19 @@
 import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient.js';
+import { streamUrl } from './src/live-query/SubscriptionChannel.js';
 export class SseSubscriptionServer {
     canUserConnectToChannel;
+    initApiServer(api) {
+        const streamPath = '/' + streamUrl;
+        api.addRoute(streamPath, 'get', async ({ req, origRes }) => {
+            this.openHttpServerStream(req, origRes);
+        });
+        api.addRoute(streamPath + '/subscribe', 'post', async ({ remult, res, getBody }) => {
+            this.subscribeToChannel(await getBody(), res, remult);
+        });
+        api.addRoute(streamPath + '/unsubscribe', 'post', async ({ remult, res, getBody }) => {
+            this.subscribeToChannel(await getBody(), res, remult, true);
+        });
+    }
     //@internal
     subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
         for (const c of this.connections) {

package/esm/server/remult-api-server.js

@@ -2,7 +2,7 @@ import { __decorate, __metadata } from "tslib";
 import { SseSubscriptionServer } from '../SseSubscriptionServer.js';
 import { Remult, RemultAsyncLocalStorage, withRemult } from '../src/context.js';
 import { DataApi, serializeError } from '../src/data-api.js';
-import { liveQueryKeepAliveRoute, streamUrl, } from '../src/live-query/SubscriptionChannel.js';
+import { liveQueryKeepAliveRoute } from '../src/live-query/SubscriptionChannel.js';
 import { InMemoryLiveQueryStorage, LiveQueryPublisher, } from '../src/live-query/SubscriptionServer.js';
 import { IdEntity } from '../src/remult3/IdEntity.js';
 import { Fields } from '../src/remult3/Fields.js';
@@ -266,19 +266,20 @@ export class RemultServerImplementation {
                 r.route(this.options.rootPath + '/admin').get(admin());
             }
             r.route(this.options.rootPath + '/me').get(this.process(async (remult, req, res) => res.success(remult.user ?? null)));
-            if (this.options.subscriptionServer instanceof SseSubscriptionServer) {
-                const streamPath = this.options.rootPath + '/' + streamUrl;
-                r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
-                    ;
-                    remult.subscriptionServer.openHttpServerStream(origReq, origRes);
-                }));
-                r.route(streamPath + '/subscribe').post(this.process(async (remult, _2, res, _, _1, origReq) => {
-                    const body = remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult);
-                }));
-                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
-                    ;
-                    remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult, true);
-                }));
+            const subscriptionServer = this.options.subscriptionServer;
+            if (isOfType(subscriptionServer, 'initApiServer')) {
+                subscriptionServer.initApiServer({
+                    rootPath: this.options.rootPath,
+                    addRoute: (relativePath, method, handler) => {
+                        r.route(this.options.rootPath + relativePath)[method](this.process(async (remult, _, res, req, origRes, origReq) => handler({
+                            remult,
+                            res,
+                            req,
+                            origRes,
+                            getBody: () => this.coreOptions.getRequestBody(origReq),
+                        })));
+                    },
+                });
             }
             r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
                 res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(await this.coreOptions.getRequestBody(origReq)));

package/internals.d.ts

@@ -14,6 +14,8 @@ export declare const actionInfo: {
 };
 export { isOfType } from './src/isOfType.js';
 export type { ClassType } from './classType.js';
+export type { SubscriptionServerWithRoutes, SubscriptionServerRouteApi, SubscriptionServerRouteHandlerArgs, } from './server/remult-api-server.js';
+export type { DataApiResponse } from './src/data-api.js';
 export { flags } from './src/remult3/remult3.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.3.15",
+    "version": "3.3.17-next.0",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/server/remult-api-server.d.ts

@@ -1,6 +1,7 @@
 import type { ClassType } from '../classType.js';
 import type { Allowed, UserInfo } from '../src/context.js';
 import { Remult } from '../src/context.js';
+import type { DataApiResponse } from '../src/data-api.js';
 import type { DataProvider } from '../src/data-interfaces.js';
 import type { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer.js';
 import { IdEntity } from '../src/remult3/IdEntity.js';
@@ -167,6 +168,22 @@ export interface GenericResponse {
     status(statusCode: number): GenericResponse;
     end(): void;
 }
+/** A `SubscriptionServer` that also needs to serve http routes (for example SSE),
+ * can implement this interface to register them on the api server */
+export interface SubscriptionServerWithRoutes extends SubscriptionServer {
+    initApiServer(api: SubscriptionServerRouteApi): void;
+}
+export interface SubscriptionServerRouteApi {
+    rootPath: string;
+    addRoute(relativePath: string, method: 'get' | 'post', handler: (args: SubscriptionServerRouteHandlerArgs) => Promise<void>): void;
+}
+export interface SubscriptionServerRouteHandlerArgs {
+    remult: Remult;
+    res: DataApiResponse;
+    req: GenericRequestInfo;
+    origRes: GenericResponse;
+    getBody(): Promise<any>;
+}
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
     userId: string;

package/server/remult-api-server.js

@@ -441,45 +441,25 @@ var RemultServerImplementation = /** @class */ (function () {
             r.route(this.options.rootPath + '/me').get(this.process(function (remult, req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () { var _a; return tslib_1.__generator(this, function (_b) {
                 return [2 /*return*/, res.success((_a = remult.user) !== null && _a !== void 0 ? _a : null)];
             }); }); }));
-            if (this.options.subscriptionServer instanceof SseSubscriptionServer_js_1.SseSubscriptionServer) {
-                var streamPath = this.options.rootPath + '/' + SubscriptionChannel_js_1.streamUrl;
-                r.route(streamPath).get(this.process(function (remult, req, res, origReq, origRes) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    return tslib_1.__generator(this, function (_a) {
-                        ;
-                        remult.subscriptionServer.openHttpServerStream(origReq, origRes);
-                        return [2 /*return*/];
-                    });
-                }); }));
-                r.route(streamPath + '/subscribe').post(this.process(function (remult, _2, res, _, _1, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var body, _a, _b;
-                    return tslib_1.__generator(this, function (_c) {
-                        switch (_c.label) {
-                            case 0:
-                                _b = (_a = remult.subscriptionServer).subscribeToChannel;
-                                return [4 /*yield*/, this.coreOptions.getRequestBody(origReq)];
-                            case 1:
-                                body = _b.apply(_a, [_c.sent(), res,
-                                    remult]);
-                                return [2 /*return*/];
-                        }
-                    });
-                }); }));
-                r.route(streamPath + '/unsubscribe').post(this.process(function (remult, req, res, reqInfo, origRes, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var _a, _b;
-                    return tslib_1.__generator(this, function (_c) {
-                        switch (_c.label) {
-                            case 0:
-                                ;
-                                _b = (_a = remult.subscriptionServer).subscribeToChannel;
-                                return [4 /*yield*/, this.coreOptions.getRequestBody(origReq)];
-                            case 1:
-                                _b.apply(_a, [_c.sent(), res,
-                                    remult,
-                                    true]);
-                                return [2 /*return*/];
-                        }
-                    });
-                }); }));
+            var subscriptionServer = this.options.subscriptionServer;
+            if ((0, isOfType_js_1.isOfType)(subscriptionServer, 'initApiServer')) {
+                subscriptionServer.initApiServer({
+                    rootPath: this.options.rootPath,
+                    addRoute: function (relativePath, method, handler) {
+                        r.route(_this.options.rootPath + relativePath)[method](_this.process(function (remult, _, res, req, origRes, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var _this = this;
+                            return tslib_1.__generator(this, function (_a) {
+                                return [2 /*return*/, handler({
+                                        remult: remult,
+                                        res: res,
+                                        req: req,
+                                        origRes: origRes,
+                                        getBody: function () { return _this.coreOptions.getRequestBody(origReq); },
+                                    })];
+                            });
+                        }); }));
+                    },
+                });
             }
             r.route(this.options.rootPath + '/' + SubscriptionChannel_js_1.liveQueryKeepAliveRoute).post(this.process(function (remult, req, res, reqInfo, origRes, origReq) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                 var _a, _b, _c, _d;

package/src/column-interfaces.d.ts

@@ -111,8 +111,8 @@ export interface FieldOptions<entityType = unknown, valueType = unknown> {
     valueConverter?: ValueConverter<valueType>;
     /** an arrow function that translates the value to a display value */
     displayValue?: (entity: entityType, value: valueType) => string;
-    /** an arrow function that determines the default value of the field, when the entity is created using the `repo.create` method */
-    defaultValue?: (entity: entityType) => valueType;
+    /** The default value of the field, when the entity is created using the `repo.create` method — a value or an arrow function that computes it */
+    defaultValue?: valueType | ((entity: entityType) => valueType);
     /** The html input type for this field */
     inputType?: string;
     /**

package/src/remult3/remult3.d.ts

@@ -1211,7 +1211,13 @@ export interface ClassDecoratorContextStub<Class extends new (...args: any) => a
     readonly name: string | undefined;
     addInitializer(initializer: (this: Class) => void): void;
 }
-export type ClassFieldDecorator<entityType, valueType> = (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
+export type ClassFieldDecorator<entityType, valueType> = ((target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void) & {
+    /** Phantom type brand (never set at runtime). Without it the decorator is a
+     * bare function type, which TypeScript skips as an inference candidate when
+     * a `Fields.xxx()` call appears in a generically-inferred object alongside a
+     * context-sensitive function — e.g. UI schemas built from field decorators. */
+    readonly __fieldValueType?: valueType;
+};
 export declare const flags: {
     error500RetryCount: number;
 };