remult 0.14.31 → 0.14.34

package/remult-fresh.js

@@ -2,14 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remultFresh = void 0;
 var tslib_1 = require("tslib");
-var remult_middleware_1 = require("./remult-middleware");
+var expressBridge_1 = require("./server/expressBridge");
 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, remult;
+    var server = expressBridge_1.buildRemultServer(options);
+    return Object.assign(server, {
+        freshHandler: 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:
@@ -25,7 +24,6 @@ function remultFresh(options, response) {
                         }
                         return [3 /*break*/, 3];
                     case 1:
-                        console.log(req);
                         _b = theReq;
                         return [4 /*yield*/, req.json()];
                     case 2:
@@ -33,25 +31,20 @@ function remultFresh(options, response) {
                         return [3 /*break*/, 3];
                     case 3:
                         init = {};
-                        return [4 /*yield*/, orig(theReq)];
+                        return [4 /*yield*/, server.handle(theReq)];
                     case 4:
                         res = _c.sent();
-                        if (!res) return [3 /*break*/, 5];
-                        if (res.statusCode)
+                        if (res) {
                             init.status = res.statusCode;
-                        if (res.data) {
-                            console.log({ init: init, res: res });
-                            return [2 /*return*/, response.json(res.data, init)];
+                            if (res.data) {
+                                return [2 /*return*/, response.json(res.data, init)];
+                            }
+                            else
+                                return [2 /*return*/, new response(undefined, init)];
+                        }
+                        else {
+                            return [2 /*return*/, ctx.next()];
                         }
-                        else
-                            return [2 /*return*/, new response(undefined, init)];
-                        return [3 /*break*/, 7];
-                    case 5: return [4 /*yield*/, mw.getRemult(req)];
-                    case 6:
-                        remult = _c.sent();
-                        ctx.state.remult = remult;
-                        return [2 /*return*/, ctx.next()];
-                    case 7:
                         ;
                         return [2 /*return*/];
                 }
@@ -61,3 +54,4 @@ function remultFresh(options, response) {
 }
 exports.remultFresh = remultFresh;
 ;
+;

package/server/JsonEntityFileStorage.d.ts

@@ -1,7 +1,10 @@
-import { JsonEntityStorage } from '../index';
+import { JsonDataProvider, JsonEntityStorage } from '../index';
 export declare class JsonEntityFileStorage implements JsonEntityStorage {
     private folderPath;
     getItem(entityDbName: string): string;
     setItem(entityDbName: string, json: string): void;
     constructor(folderPath: string);
 }
+export declare class JsonFileDataProvider extends JsonDataProvider {
+    constructor(folderPath: string);
+}

package/server/JsonEntityFileStorage.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonEntityFileStorage = void 0;
+exports.JsonFileDataProvider = exports.JsonEntityFileStorage = void 0;
+var tslib_1 = require("tslib");
 var path = require("path");
 var fs = require("fs");
+var index_1 = require("../index");
 var JsonEntityFileStorage = /** @class */ (function () {
     function JsonEntityFileStorage(folderPath) {
         this.folderPath = folderPath;
@@ -23,3 +25,11 @@ var JsonEntityFileStorage = /** @class */ (function () {
     return JsonEntityFileStorage;
 }());
 exports.JsonEntityFileStorage = JsonEntityFileStorage;
+var JsonFileDataProvider = /** @class */ (function (_super) {
+    tslib_1.__extends(JsonFileDataProvider, _super);
+    function JsonFileDataProvider(folderPath) {
+        return _super.call(this, new JsonEntityFileStorage(folderPath)) || this;
+    }
+    return JsonFileDataProvider;
+}(index_1.JsonDataProvider));
+exports.JsonFileDataProvider = JsonFileDataProvider;

package/server/expressBridge.d.ts

@@ -1,7 +1,6 @@
 import { queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
-import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
-import { AllowedForInstance, Remult, UserInfo } from '../src/context';
+import { Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
@@ -11,7 +10,6 @@ export declare type RemultServerOptions = {
      * @see [Connecting to a Database](https://remult.dev/docs/databases.html).
     */
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
-    disableAutoApi?: boolean;
     queueStorage?: QueueStorage;
     initRequest?: (remult: Remult, origReq: GenericRequest) => Promise<void>;
     getUser?: (request: GenericRequest) => Promise<UserInfo>;
@@ -22,25 +20,28 @@ export declare type RemultServerOptions = {
     controllers?: ClassType<any>[];
     rootPath?: string;
 };
-export declare function buildRemultServer(app: GenericRouter, options: RemultServerOptions): RemultServer;
-export declare type GenericMiddleware = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
-export interface RemultExpressBridge extends GenericMiddleware, RemultServer {
+export declare function buildRemultServer(options: RemultServerOptions): RemultServer;
+export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
+export interface ServerHandleResponse {
+    data?: any;
+    statusCode: number;
 }
 export interface RemultServer {
     getRemult(req: GenericRequest): Promise<Remult>;
     openApiDoc(options: {
         title: string;
     }): any;
-    addArea(rootUrl: string): void;
+    registerRouter(r: GenericRouter): void;
+    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;
 };
 export declare type SpecificRoute = {
-    get(handler: GenericMiddleware): SpecificRoute;
-    put(handler: GenericMiddleware): SpecificRoute;
-    post(handler: GenericMiddleware): SpecificRoute;
-    delete(handler: GenericMiddleware): SpecificRoute;
+    get(handler: GenericRequestHandler): SpecificRoute;
+    put(handler: GenericRequestHandler): SpecificRoute;
+    post(handler: GenericRequestHandler): SpecificRoute;
+    delete(handler: GenericRequestHandler): SpecificRoute;
 };
 export interface GenericRequest {
     url?: string;
@@ -51,57 +52,9 @@ export interface GenericRequest {
 }
 export interface GenericResponse {
     json(data: any): any;
-    status?(statusCode: number): GenericResponse;
-    setStatus?(statusCode: number): GenericResponse;
+    status(statusCode: number): GenericResponse;
     end(): any;
 }
-declare class ExpressBridge {
-    private app;
-    queue: inProcessQueueHandler;
-    options: RemultServerOptions;
-    dataProvider: DataProvider | Promise<DataProvider>;
-    openApiDoc(options: {
-        title: string;
-        version?: string;
-    }): any;
-    backendMethodsOpenApi: {
-        path: string;
-        allowed: AllowedForInstance<any>;
-        tag: string;
-    }[];
-    constructor(app: GenericRouter, queue: inProcessQueueHandler, options: RemultServerOptions, dataProvider: DataProvider | Promise<DataProvider>);
-    logApiEndPoints: boolean;
-    private firstArea;
-    addArea(rootUrl: string): SiteArea;
-    getRemult(req?: GenericRequest): Promise<Remult>;
-}
-export declare class SiteArea {
-    private bridge;
-    private app;
-    private rootUrl;
-    private logApiEndpoints;
-    constructor(bridge: ExpressBridge, app: GenericRouter, rootUrl: string, logApiEndpoints: boolean);
-    add(key: string, dataApiFactory: ((req: Remult) => DataApi)): void;
-    process(what: (remult: Remult, myReq: DataApiRequest, myRes: DataApiResponse, origReq: GenericRequest) => Promise<void>): (req: GenericRequest, res: GenericResponse) => Promise<void>;
-    getRemult(req: GenericRequest): Promise<Remult>;
-    initQueue(): void;
-    addAction(action: {
-        __register: (reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: Remult, res: DataApiResponse) => void)) => void) => void;
-    }): void;
-}
-export declare class ExpressRequestBridgeToDataApiRequest implements DataApiRequest {
-    private r;
-    get(key: string): any;
-    constructor(r: GenericRequest);
-}
-declare class inProcessQueueHandler {
-    private storage;
-    constructor(storage: QueueStorage);
-    submitJob(url: string, req: Remult, body: any): Promise<string>;
-    mapQueuedAction(url: string, what: (data: any, r: Remult, res: ApiActionResponse) => void): void;
-    actions: Map<string, (data: any, r: Remult, res: ApiActionResponse) => void>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
-}
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
     userId: string;
@@ -136,4 +89,3 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
-export {};