remult 0.23.5 → 0.23.6

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/esm/remult-nuxt.js

@@ -0,0 +1,49 @@
+import { readBody } from 'h3';
+import { createRemultServer, } from './server/index.js';
+export function remultNuxt(options) {
+    const result = createRemultServer(options, {
+        buildGenericRequestInfo: (event) => {
+            return {
+                method: event.node.req.method,
+                url: event.node.req.url,
+                on: (a, b) => event.node.req.on('close', () => {
+                    b();
+                }),
+            };
+        },
+        getRequestBody: async (event) => await readBody(event),
+    });
+    const handler = async (event) => {
+        let sse = false;
+        const response = {
+            end: () => { },
+            json: () => { },
+            status: () => {
+                return response;
+            },
+            write: (what) => {
+                event.node.res.write(what);
+            },
+            writeHead: (status, headers) => {
+                sse = true;
+                event.node.res.writeHead(status, headers);
+            },
+        };
+        const r = await result.handle(event, response);
+        if (sse) {
+            await new Promise((resolve) => {
+                event.node.req.on('close', () => resolve({}));
+            });
+        }
+        if (r) {
+            return r.data;
+        }
+    };
+    return Object.assign(handler, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        withRemult(event, what) {
+            return result.withRemultAsync(event, what);
+        },
+    });
+}

package/esm/src/remult3/RepositoryImplementation.js

@@ -176,11 +176,21 @@ export class RepositoryImplementation {
         return x;
     }
     async delete(item) {
+        const ref = getEntityRef(item, false);
+        if (ref)
+            return ref.delete();
         if (typeof item === 'string' || typeof item === 'number')
-            return this.edp.delete(item);
-        else {
-            return this.getRefForExistingRow(item, undefined).delete();
-        }
+            if (this.dataProvider.isProxy)
+                return this.edp.delete(item);
+            else {
+                let ref2 = await this.findId(item);
+                if (ref2)
+                    return await getEntityRef(ref2).delete();
+            }
+        let ref2 = this.getRefForExistingRow(item, undefined);
+        if (!this.dataProvider.isProxy)
+            await ref2.reload();
+        return ref2.delete();
     }
     async insert(entity) {
         if (Array.isArray(entity)) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.23.5",
+    "version": "0.23.6",
     "description": "A CRUD framework for full-stack TypeScript",
     "types": "index.d.ts",
     "module": "esm/index.js",

package/remult-nuxt.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+import { RemultServerCore, RemultServerOptions, RemultServer } from './server/index.js';
+export declare function remultNuxt(options: RemultServerOptions<H3Event>): RemultNuxtServer;
+export type RemultNuxtServer = RemultServerCore<H3Event> & ((event: H3Event) => Promise<any>) & {
+    withRemult: RemultServer<H3Event>['withRemultAsync'];
+};

package/remult-nuxt.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultNuxt = void 0;
+var tslib_1 = require("tslib");
+var h3_1 = require("h3");
+var index_js_1 = require("./server/index.js");
+function remultNuxt(options) {
+    var _this = this;
+    var result = (0, index_js_1.createRemultServer)(options, {
+        buildGenericRequestInfo: function (event) {
+            return {
+                method: event.node.req.method,
+                url: event.node.req.url,
+                on: function (a, b) {
+                    return event.node.req.on('close', function () {
+                        b();
+                    });
+                },
+            };
+        },
+        getRequestBody: function (event) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, h3_1.readBody)(event)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); },
+    });
+    var handler = function (event) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var sse, response, r;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sse = false;
+                    response = {
+                        end: function () { },
+                        json: function () { },
+                        status: function () {
+                            return response;
+                        },
+                        write: function (what) {
+                            event.node.res.write(what);
+                        },
+                        writeHead: function (status, headers) {
+                            sse = true;
+                            event.node.res.writeHead(status, headers);
+                        },
+                    };
+                    return [4 /*yield*/, result.handle(event, response)];
+                case 1:
+                    r = _a.sent();
+                    if (!sse) return [3 /*break*/, 3];
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            event.node.req.on('close', function () { return resolve({}); });
+                        })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    if (r) {
+                        return [2 /*return*/, r.data];
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    return Object.assign(handler, {
+        getRemult: function (req) { return result.getRemult(req); },
+        openApiDoc: function (options) { return result.openApiDoc(options); },
+        withRemult: function (event, what) {
+            return result.withRemultAsync(event, what);
+        },
+    });
+}
+exports.remultNuxt = remultNuxt;

package/src/remult3/RepositoryImplementation.js

@@ -233,13 +233,31 @@ var RepositoryImplementation = /** @class */ (function () {
     };
     RepositoryImplementation.prototype.delete = function (item) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var ref, ref2_1, ref2;
             return tslib_1.__generator(this, function (_a) {
-                if (typeof item === 'string' || typeof item === 'number')
-                    return [2 /*return*/, this.edp.delete(item)];
-                else {
-                    return [2 /*return*/, this.getRefForExistingRow(item, undefined).delete()];
+                switch (_a.label) {
+                    case 0:
+                        ref = (0, getEntityRef_1.getEntityRef)(item, false);
+                        if (ref)
+                            return [2 /*return*/, ref.delete()];
+                        if (!(typeof item === 'string' || typeof item === 'number')) return [3 /*break*/, 4];
+                        if (!this.dataProvider.isProxy) return [3 /*break*/, 1];
+                        return [2 /*return*/, this.edp.delete(item)];
+                    case 1: return [4 /*yield*/, this.findId(item)];
+                    case 2:
+                        ref2_1 = _a.sent();
+                        if (!ref2_1) return [3 /*break*/, 4];
+                        return [4 /*yield*/, (0, getEntityRef_1.getEntityRef)(ref2_1).delete()];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        ref2 = this.getRefForExistingRow(item, undefined);
+                        if (!!this.dataProvider.isProxy) return [3 /*break*/, 6];
+                        return [4 /*yield*/, ref2.reload()];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, ref2.delete()];
                 }
-                return [2 /*return*/];
             });
         });
     };