remult 0.14.27 → 0.14.30

package/esm/remult-fastify.js

@@ -19,7 +19,7 @@ export function remultFastify(options) {
         return response;
     }
     let api;
-    const pluginFunction = async (instance, options) => {
+    const pluginFunction = async (instance, op) => {
         //@ts-ignore
         let fastifyRouter = {
             route(path) {

package/esm/remult-fresh.d.ts

@@ -0,0 +1,18 @@
+import { RemultMiddlewareOptions, RemultServer } from "./server/expressBridge";
+export declare function remultFresh(options: RemultMiddlewareOptions, response: FreshResponse): RemultFresh;
+export interface RemultFresh extends RemultServer {
+    handle(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+}
+interface FreshRequest {
+    url: string;
+    method: string;
+    json: () => Promise<any>;
+}
+interface FreshContext {
+    next: () => Promise<any>;
+}
+interface FreshResponse {
+    new (body?: any | undefined, init?: ResponseInit): any;
+    json(data: unknown, init?: ResponseInit): any;
+}
+export {};

package/esm/remult-fresh.js

@@ -0,0 +1,39 @@
+import { remultMiddleware } from "./remult-middleware";
+export function remultFresh(options, response) {
+    const mw = remultMiddleware(options);
+    const orig = mw.handle;
+    return {
+        ...mw,
+        ...{
+            handle: async (req, ctx) => {
+                const theReq = {
+                    method: req.method,
+                    url: req.url,
+                    body: undefined
+                };
+                switch (req.method.toLocaleLowerCase()) {
+                    case "put":
+                    case "post":
+                        console.log(req);
+                        theReq.body = await req.json();
+                        break;
+                }
+                let init = {};
+                const res = await orig(theReq);
+                if (res) {
+                    if (res.statusCode)
+                        init.status = res.statusCode;
+                    if (res.data) {
+                        console.log({ init, res });
+                        return response.json(res.data, init);
+                    }
+                    else
+                        return new response(undefined, init);
+                }
+                else
+                    return ctx.next();
+            }
+        }
+    };
+}
+;

package/esm/remult-middleware.d.ts

@@ -1,4 +1,4 @@
-import { GenericRequest, GenericRequestHandler, GenericResponse, RemultMiddlewareOptions, RemultServer } from './server/expressBridge';
+import { GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultMiddlewareOptions, SpecificRoute, RemultServer } from './server/expressBridge';
 export declare function remultMiddleware(options?: RemultMiddlewareOptions): RemultMiddleware;
 export interface RemultMiddleware extends GenericRequestHandler, RemultServer {
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<MiddlewareResponse>;
@@ -7,3 +7,4 @@ export interface MiddlewareResponse {
     data?: any;
     statusCode?: number;
 }
+export { GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultMiddlewareOptions, SpecificRoute, RemultServer };

package/esm/remult-middleware.js

@@ -6,7 +6,7 @@ export function remultMiddleware(options) {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
         addArea: x => server.addArea(x),
-        handle: req => m.handle(req)
+        handle: (req, res) => m.handle(req, res)
     });
 }
 class middleware {
@@ -44,18 +44,18 @@ class middleware {
         return new Promise(res => {
             const response = new class {
                 json(data) {
-                    if (gRes)
+                    if (gRes !== undefined)
                         gRes.json(data);
                     res({ statusCode: this.statusCode, data });
                 }
                 status(statusCode) {
-                    if (gRes)
+                    if (gRes !== undefined)
                         gRes.status(statusCode);
                     this.statusCode = statusCode;
                     return this;
                 }
                 end() {
-                    if (gRes)
+                    if (gRes !== undefined)
                         gRes.end();
                     res({
                         statusCode: this.statusCode
@@ -114,3 +114,4 @@ class middleware {
         next();
     }
 }
+export { buildRemultServer };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.14.27",
+    "version": "0.14.30",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -36,6 +36,10 @@
             "require": "./remult-fastify.js",
             "import": "./esm/remult-fastify.js"
         },
+        "./remult-fresh": {
+            "require": "./remult-fresh.js",
+            "import": "./esm/remult-fresh.js"
+        },
         "./postgres": {
             "require": "./postgres/index.js",
             "import": "./esm/postgres/index.js"

package/remult-fastify.js

@@ -24,7 +24,7 @@ function remultFastify(options) {
         return response;
     }
     var api;
-    var pluginFunction = function (instance, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+    var pluginFunction = function (instance, op) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var fastifyRouter;
         return tslib_1.__generator(this, function (_a) {
             fastifyRouter = {

package/remult-fresh.d.ts

@@ -0,0 +1,18 @@
+import { RemultMiddlewareOptions, RemultServer } from "./server/expressBridge";
+export declare function remultFresh(options: RemultMiddlewareOptions, response: FreshResponse): RemultFresh;
+export interface RemultFresh extends RemultServer {
+    handle(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+}
+interface FreshRequest {
+    url: string;
+    method: string;
+    json: () => Promise<any>;
+}
+interface FreshContext {
+    next: () => Promise<any>;
+}
+interface FreshResponse {
+    new (body?: any | undefined, init?: ResponseInit): any;
+    json(data: unknown, init?: ResponseInit): any;
+}
+export {};

package/remult-fresh.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultFresh = void 0;
+var tslib_1 = require("tslib");
+var remult_middleware_1 = require("./remult-middleware");
+function remultFresh(options, response) {
+    var _this = this;
+    var mw = remult_middleware_1.remultMiddleware(options);
+    var orig = mw.handle;
+    return tslib_1.__assign(tslib_1.__assign({}, mw), {
+        handle: function (req, ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var theReq, _a, _b, init, res;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        theReq = {
+                            method: req.method,
+                            url: req.url,
+                            body: undefined
+                        };
+                        _a = req.method.toLocaleLowerCase();
+                        switch (_a) {
+                            case "put": return [3 /*break*/, 1];
+                            case "post": return [3 /*break*/, 1];
+                        }
+                        return [3 /*break*/, 3];
+                    case 1:
+                        console.log(req);
+                        _b = theReq;
+                        return [4 /*yield*/, req.json()];
+                    case 2:
+                        _b.body = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 3:
+                        init = {};
+                        return [4 /*yield*/, orig(theReq)];
+                    case 4:
+                        res = _c.sent();
+                        if (res) {
+                            if (res.statusCode)
+                                init.status = res.statusCode;
+                            if (res.data) {
+                                console.log({ init: init, res: res });
+                                return [2 /*return*/, response.json(res.data, init)];
+                            }
+                            else
+                                return [2 /*return*/, new response(undefined, init)];
+                        }
+                        else
+                            return [2 /*return*/, ctx.next()];
+                        return [2 /*return*/];
+                }
+            });
+        }); }
+    });
+}
+exports.remultFresh = remultFresh;
+;

package/remult-middleware.d.ts

@@ -1,4 +1,4 @@
-import { GenericRequest, GenericRequestHandler, GenericResponse, RemultMiddlewareOptions, RemultServer } from './server/expressBridge';
+import { GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultMiddlewareOptions, SpecificRoute, RemultServer } from './server/expressBridge';
 export declare function remultMiddleware(options?: RemultMiddlewareOptions): RemultMiddleware;
 export interface RemultMiddleware extends GenericRequestHandler, RemultServer {
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<MiddlewareResponse>;
@@ -7,3 +7,4 @@ export interface MiddlewareResponse {
     data?: any;
     statusCode?: number;
 }
+export { GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultMiddlewareOptions, SpecificRoute, RemultServer };

package/remult-middleware.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultMiddleware = void 0;
+exports.buildRemultServer = exports.remultMiddleware = void 0;
 var tslib_1 = require("tslib");
 var expressBridge_1 = require("./server/expressBridge");
+Object.defineProperty(exports, "buildRemultServer", { enumerable: true, get: function () { return expressBridge_1.buildRemultServer; } });
 function remultMiddleware(options) {
     var m = new middleware();
     var server = expressBridge_1.buildRemultServer(m, options);
@@ -10,7 +11,7 @@ function remultMiddleware(options) {
         getRemult: function (req) { return server.getRemult(req); },
         openApiDoc: function (options) { return server.openApiDoc(options); },
         addArea: function (x) { return server.addArea(x); },
-        handle: function (req) { return m.handle(req); }
+        handle: function (req, res) { return m.handle(req, res); }
     });
 }
 exports.remultMiddleware = remultMiddleware;
@@ -54,18 +55,18 @@ var middleware = /** @class */ (function () {
                             function class_1() {
                             }
                             class_1.prototype.json = function (data) {
-                                if (gRes)
+                                if (gRes !== undefined)
                                     gRes.json(data);
                                 res({ statusCode: this.statusCode, data: data });
                             };
                             class_1.prototype.status = function (statusCode) {
-                                if (gRes)
+                                if (gRes !== undefined)
                                     gRes.status(statusCode);
                                 this.statusCode = statusCode;
                                 return this;
                             };
                             class_1.prototype.end = function () {
-                                if (gRes)
+                                if (gRes !== undefined)
                                     gRes.end();
                                 res({
                                     statusCode: this.statusCode