remult 3.3.17-next.0 → 3.3.17

package/SseSubscriptionServer.d.ts

@@ -1,9 +1,8 @@
 import type { GenericResponse } from './server/index.js';
-import type { SubscriptionServerRouteApi, SubscriptionServerWithRoutes } from './server/remult-api-server.js';
 import type { Remult } from './src/context.js';
-export declare class SseSubscriptionServer implements SubscriptionServerWithRoutes {
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
+export declare class SseSubscriptionServer implements SubscriptionServer {
     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,7 +3,6 @@ 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;
@@ -17,45 +16,6 @@ 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,19 +1,6 @@
 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 } from '../src/live-query/SubscriptionChannel.js';
+import { liveQueryKeepAliveRoute, streamUrl, } 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,20 +266,19 @@ 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)));
-            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),
-                        })));
-                    },
-                });
+            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);
+                }));
             }
             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/esm/src/remult3/RepositoryImplementation.js

@@ -1698,8 +1698,10 @@ export class rowHelperImplementation extends rowHelperBase {
                 }
             }
             else if (!getRelationFieldInfo(col))
-                if (data[col.key] === undefined)
-                    delete this.instance[col.key];
+                if (data[col.key] === undefined) {
+                    if (!Reflect.deleteProperty(this.instance, col.key))
+                        this.instance[col.key] = undefined;
+                }
                 else
                     this.instance[col.key] = data[col.key];
         }

package/internals.d.ts

@@ -14,8 +14,6 @@ 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.17-next.0",
+    "version": "3.3.17",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

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

@@ -1,7 +1,6 @@
 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';
@@ -168,22 +167,6 @@ 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,25 +441,45 @@ 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)];
             }); }); }));
-            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); },
-                                    })];
-                            });
-                        }); }));
-                    },
-                });
+            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*/];
+                        }
+                    });
+                }); }));
             }
             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/remult3/RepositoryImplementation.js

@@ -2856,8 +2856,10 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                     case 6: return [3 /*break*/, 8];
                     case 7:
                         if (!(0, relationInfoMember_js_1.getRelationFieldInfo)(col))
-                            if (data[col.key] === undefined)
-                                delete this.instance[col.key];
+                            if (data[col.key] === undefined) {
+                                if (!Reflect.deleteProperty(this.instance, col.key))
+                                    this.instance[col.key] = undefined;
+                            }
                             else
                                 this.instance[col.key] = data[col.key];
                         _d.label = 8;