remult 0.14.30 → 0.14.33

package/{readme.md → README.md}

@@ -35,13 +35,13 @@
 
 ### Status
 
-Remult is **production-ready** and, in fact, used in production apps since 2017. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
+Remult is **production-ready** and, in fact, used in production apps since 2018. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
 
 ## Motivation
 
 Full-stack web development is (still) too complicated. **Simple CRUD, a common requirement of any business application, should be simple to build, maintain, and extend** when the need arises.
 
-Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult let you write TypeScript code you can follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
+Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult helps building fullstack apps using only TypeScript code you can easily follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
 
 Other frameworks tend to fall into either too much abstraction (no-code, low-code, BaaS) or partial abstraction (MVC frameworks, GraphQL, ORMs, API generators, code generators), and tend to be opinionated regarding the development tool-chain, deployment environment, configuration/conventions or DSL. Remult attempts to strike a better balance.
 

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 { RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultExpress(options?: RemultMiddlewareOptions & {
+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.d.ts

@@ -1,3 +1,3 @@
 import type { FastifyPluginCallback } from 'fastify';
-import { RemultServer, RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultMiddlewareOptions): FastifyPluginCallback & RemultServer;
+import { RemultServer, RemultServerOptions } from './server/expressBridge';
+export declare function remultFastify(options: RemultServerOptions): FastifyPluginCallback & RemultServer;

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

package/esm/remult-fresh.js

@@ -1,39 +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);
+    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 ctx.next();
+                    return new response(undefined, init);
             }
+            else {
+                return ctx.next();
+            }
+            ;
         }
-    };
+    });
 }
 ;
+;

package/esm/server/expressBridge.d.ts

@@ -1,37 +1,38 @@
 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';
-export declare type RemultMiddlewareOptions = {
+export declare type RemultServerOptions = {
     /** Sets a database connection for Remult.
      *
      * @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>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
     entities?: ClassType<any>[];
     controllers?: ClassType<any>[];
-    bodyParser?: boolean;
     rootPath?: string;
 };
-export declare function buildRemultServer(app: GenericRouter, options: RemultMiddlewareOptions): RemultServer;
+export declare function buildRemultServer(options: RemultServerOptions): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
-export interface RemultExpressBridge extends GenericRequestHandler, RemultServer {
+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;
@@ -48,62 +49,12 @@ export interface GenericRequest {
     body?: any;
     query?: any;
     params?: any;
-    user?: UserInfo;
-    auth?: UserInfo;
 }
 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;
-    initRequest: (remult: Remult, origReq: GenericRequest) => Promise<void>;
-    dataProvider: DataProvider | Promise<DataProvider>;
-    openApiDoc(options: {
-        title: string;
-        version?: string;
-    }): any;
-    backendMethodsOpenApi: {
-        path: string;
-        allowed: AllowedForInstance<any>;
-        tag: string;
-    }[];
-    constructor(app: GenericRouter, queue: inProcessQueueHandler, initRequest: (remult: Remult, origReq: GenericRequest) => Promise<void>, 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;
@@ -138,4 +89,3 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
-export {};