remult 0.14.31 → 0.14.32

package/esm/graphql.d.ts

@@ -1,5 +1,5 @@
-import { RemultExpressBridge } from "./server/expressBridge";
-export declare function remultGraphql(api: RemultExpressBridge): {
+import { RemultServer } from "./server/expressBridge";
+export declare function remultGraphql(api: RemultServer): {
     rootValue: {};
     schema: string;
 };

package/esm/remult-express.d.ts

@@ -1,11 +1,6 @@
-import { RemultServerOptions } from './server/expressBridge';
+import * as express from 'express';
+import { RemultServer, RemultServerOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultServerOptions & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): import("express-serve-static-core").Router & {
-    getRemult: (req: any) => Promise<import(".").Remult>;
-    openApiDoc: (options: {
-        title: string;
-    }) => any;
-    addArea: (x: any) => void;
-};
+}): express.RequestHandler & RemultServer;

package/esm/remult-express.js

@@ -12,10 +12,11 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    const server = buildRemultServer(app, options);
+    const server = buildRemultServer(options);
+    server.registerRouter(app);
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
-        addArea: x => server.addArea(x)
+        registerRouter: x => server.registerRouter(x)
     });
 }

package/esm/remult-fastify.js

@@ -18,7 +18,7 @@ export function remultFastify(options) {
         };
         return response;
     }
-    let api;
+    const api = buildRemultServer(options);
     const pluginFunction = async (instance, op) => {
         //@ts-ignore
         let fastifyRouter = {
@@ -42,16 +42,11 @@ export function remultFastify(options) {
                 return r;
             },
         };
-        api = buildRemultServer(fastifyRouter, options);
-    };
-    const getApi = () => {
-        if (!api)
-            throw "Please call fastify's register before using this method";
-        return api;
+        api.registerRouter(fastifyRouter);
     };
     return Object.assign(pluginFunction, {
-        addArea: x => getApi().addArea(x),
-        getRemult: x => getApi().getRemult(x),
-        openApiDoc: x => getApi().openApiDoc(x)
+        getRemult: x => api.getRemult(x),
+        openApiDoc: x => api.openApiDoc(x),
+        handle: (req, res) => api.handle(req, res)
     });
 }

package/esm/remult-fresh.d.ts

@@ -1,8 +1,7 @@
 import { RemultServerOptions, RemultServer } from "./server/expressBridge";
-import { Remult } from "./src/context";
 export declare function remultFresh(options: RemultServerOptions, response: FreshResponse): RemultFresh;
 export interface RemultFresh extends RemultServer {
-    handle(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+    freshHandler(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
 }
 export interface FreshRequest {
     url: string;
@@ -11,12 +10,8 @@ export interface FreshRequest {
 }
 export interface FreshContext {
     next: () => Promise<any>;
-    state: FreshRemultState;
 }
 export interface FreshResponse {
     new (body?: any | undefined, init?: ResponseInit): any;
     json(data: unknown, init?: ResponseInit): any;
 }
-export interface FreshRemultState {
-    remult: Remult;
-}

package/esm/remult-fresh.js

@@ -1,43 +1,36 @@
-import { remultMiddleware } from "./remult-middleware";
+import { buildRemultServer } from "./server/expressBridge";
 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 {
-                    const remult = await mw.getRemult(req);
-                    ctx.state.remult = remult;
-                    return ctx.next();
+    const server = buildRemultServer(options);
+    const orig = server.handle;
+    return Object.assign(server, {
+        freshHandler: async (req, ctx) => {
+            const theReq = {
+                method: req.method,
+                url: req.url,
+                body: undefined
+            };
+            switch (req.method.toLocaleLowerCase()) {
+                case "put":
+                case "post":
+                    theReq.body = await req.json();
+                    break;
+            }
+            let init = {};
+            const res = await orig(theReq);
+            if (res) {
+                init.status = res.statusCode;
+                if (res.data) {
+                    return response.json(res.data, init);
                 }
-                ;
+                else
+                    return new response(undefined, init);
             }
+            else {
+                return ctx.next();
+            }
+            ;
         }
-    };
+    });
 }
 ;
+;

package/esm/server/expressBridge.d.ts

@@ -1,7 +1,7 @@
 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 { DataApiRequest } from '../src/data-api';
+import { Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
@@ -11,7 +11,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 +21,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;
@@ -55,53 +57,11 @@ export interface GenericResponse {
     setStatus?(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 +96,3 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
-export {};