remult 0.13.29 → 0.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.13.29",
+    "version": "0.14.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev/",
     "repository": {

package/remult-express.d.ts

@@ -1 +1,5 @@
-export { remultExpress, RemultExpressBridge } from './server/expressBridge';
+import { RemultMiddlewareOptions } from './server/expressBridge';
+export declare function remultExpress(options?: RemultMiddlewareOptions & {
+    bodyParser?: boolean;
+    bodySizeLimit?: string;
+}): import("./server/expressBridge").RemultExpressBridge;

package/remult-express.js

@@ -1,5 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remultExpress = void 0;
+var express = require("express");
 var expressBridge_1 = require("./server/expressBridge");
-Object.defineProperty(exports, "remultExpress", { enumerable: true, get: function () { return expressBridge_1.remultExpress; } });
+function remultExpress(options) {
+    var app = express.Router();
+    if (!options) {
+        options = {};
+    }
+    if (options.bodySizeLimit === undefined) {
+        options.bodySizeLimit = '10mb';
+    }
+    if ((options === null || options === void 0 ? void 0 : options.bodyParser) !== false) {
+        app.use(express.json({ limit: options.bodySizeLimit }));
+        app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
+    }
+    return expressBridge_1.remultMiddlewareBase(app, options);
+}
+exports.remultExpress = remultExpress;

package/remult-middleware.d.ts

@@ -0,0 +1,2 @@
+import { RemultMiddlewareOptions } from './server/expressBridge';
+export declare function remultMiddleware(options?: RemultMiddlewareOptions): import("./server/expressBridge").RemultExpressBridge;

package/remult-middleware.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultMiddleware = void 0;
+var expressBridge_1 = require("./server/expressBridge");
+function remultMiddleware(options) {
+    var m = new middleware();
+    var app = Object.assign(m, function (req, res, next) { return m.handleRequest(req, res, next); });
+    return expressBridge_1.remultMiddlewareBase(app, options);
+}
+exports.remultMiddleware = remultMiddleware;
+var middleware = /** @class */ (function () {
+    function middleware() {
+        this.map = new Map();
+    }
+    middleware.prototype.route = function (path) {
+        //consider using:
+        //* https://raw.githubusercontent.com/cmorten/opine/main/src/utils/pathToRegex.ts
+        //* https://github.com/pillarjs/path-to-regexp
+        var r = path.toLowerCase();
+        var m = new Map();
+        this.map.set(r, m);
+        var route = {
+            get: function (h) {
+                m.set("get", h);
+                return route;
+            },
+            put: function (h) {
+                m.set("put", h);
+                return route;
+            },
+            post: function (h) {
+                m.set("post", h);
+                return route;
+            },
+            delete: function (h) {
+                m.set("delete", h);
+                return route;
+            }
+        };
+        return route;
+    };
+    middleware.prototype.handleRequest = function (req, res, next) {
+        var lowerPath = req.path.toLowerCase();
+        var m = this.map.get(lowerPath);
+        if (m) {
+            var h = m.get(req.method.toLowerCase());
+            if (h) {
+                h(req, res, next);
+                return;
+            }
+        }
+        var idPosition = req.path.lastIndexOf('/');
+        if (idPosition >= 0) {
+            lowerPath = req.path.substring(0, idPosition) + '/:id';
+            m = this.map.get(lowerPath);
+            if (m) {
+                var h = m.get(req.method.toLowerCase());
+                if (h) {
+                    req.params.id = req.path.substring(idPosition + 1);
+                    h(req, res, next);
+                    return;
+                }
+            }
+        }
+        console.log(req.path);
+        next();
+    };
+    return middleware;
+}());

package/server/expressBridge.d.ts

@@ -1,20 +1,18 @@
 import { DataProvider, Remult, IdEntity } from '../';
-import * as express from 'express';
 import { Repository } from '../src/remult3';
 import { queuedJobInfoResponse } from '../src/server-action';
 import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
 import { AllowedForInstance } from '../src/context';
 import { ClassType } from '../classType';
-export declare function remultExpress(options?: {
+export declare type RemultMiddlewareOptions = {
     /** Sets a database connection for Remult.
      *
      * @see [Connecting to a Database](https://remult.dev/docs/databases.html).
     */
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
-    bodySizeLimit?: string;
     disableAutoApi?: boolean;
     queueStorage?: QueueStorage;
-    initRequest?: (remult: Remult, origReq: express.Request) => Promise<void>;
+    initRequest?: (remult: Remult, origReq: GenericRequest) => Promise<void>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
@@ -22,42 +20,70 @@ export declare function remultExpress(options?: {
     controllers?: ClassType<any>[];
     bodyParser?: boolean;
     rootPath?: string;
-}): RemultExpressBridge;
-export interface RemultExpressBridge extends express.RequestHandler {
-    getRemult(req: express.Request): Promise<Remult>;
+};
+export declare function remultMiddlewareBase(app: GenericRouter, options: RemultMiddlewareOptions): RemultExpressBridge;
+export interface RemultExpressBridge extends GenericRequestHandler {
+    getRemult(req: GenericRequest): Promise<Remult>;
     openApiDoc(options: {
         title: string;
     }): any;
     addArea(rootUrl: string): any;
 }
+export interface GenericRequest {
+    method: any;
+    path: any;
+    originalUrl: any;
+    query: any;
+    body: any;
+    params: any;
+}
+export interface GenericResponse {
+    status(arg0: number): any;
+    statusCode: number;
+    json(data: any): any;
+    writeHead(status: number): {
+        end: VoidFunction;
+    };
+}
+export declare type GenericRouter = GenericRequestHandler & {
+    route(path: string): SpecificRoute;
+};
+export declare type SpecificRoute = {
+    get(handler: GenericRequestHandler): SpecificRoute;
+    put(handler: GenericRequestHandler): SpecificRoute;
+    post(handler: GenericRequestHandler): SpecificRoute;
+    delete(handler: GenericRequestHandler): SpecificRoute;
+};
+export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 declare class ExpressBridge {
     private app;
     queue: inProcessQueueHandler;
-    initRequest: (remult: Remult, origReq: express.Request) => Promise<void>;
+    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: express.Router, queue: inProcessQueueHandler, initRequest: (remult: Remult, origReq: express.Request) => Promise<void>, dataProvider: DataProvider | Promise<DataProvider>);
+    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?: express.Request): Promise<Remult>;
+    getRemult(req?: GenericRequest): Promise<Remult>;
 }
 export declare class SiteArea {
     private bridge;
     private app;
     private rootUrl;
     private logApiEndpoints;
-    constructor(bridge: ExpressBridge, app: express.Router, rootUrl: string, logApiEndpoints: boolean);
+    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: express.Request) => Promise<void>): (req: express.Request, res: express.Response) => Promise<void>;
-    getRemult(req: express.Request): Promise<Remult>;
+    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;
@@ -66,7 +92,7 @@ export declare class SiteArea {
 export declare class ExpressRequestBridgeToDataApiRequest implements DataApiRequest {
     private r;
     get(key: string): any;
-    constructor(r: express.Request);
+    constructor(r: GenericRequest);
 }
 declare class inProcessQueueHandler {
     private storage;

package/server/expressBridge.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.ExpressRequestBridgeToDataApiRequest = exports.SiteArea = exports.remultExpress = void 0;
+exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.ExpressRequestBridgeToDataApiRequest = exports.SiteArea = exports.remultMiddlewareBase = void 0;
 var tslib_1 = require("tslib");
 var __1 = require("../");
-var express = require("express");
 var register_actions_on_server_1 = require("./register-actions-on-server");
 var register_entities_on_server_1 = require("./register-entities-on-server");
 var JsonEntityFileStorage_1 = require("./JsonEntityFileStorage");
@@ -12,9 +11,8 @@ var remult3_1 = require("../src/remult3");
 var server_action_1 = require("../src/server-action");
 var data_api_1 = require("../src/data-api");
 var context_1 = require("../src/context");
-function remultExpress(options) {
+function remultMiddlewareBase(app, options) {
     var _this = this;
-    var app = express.Router();
     if (!options) {
         options = {};
     }
@@ -22,16 +20,9 @@ function remultExpress(options) {
     if (options.defaultGetLimit) {
         data_api_1.DataApi.defaultGetLimit = options.defaultGetLimit;
     }
-    if (options.bodySizeLimit === undefined) {
-        options.bodySizeLimit = '10mb';
-    }
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    if ((options === null || options === void 0 ? void 0 : options.bodyParser) !== false) {
-        app.use(express.json({ limit: options.bodySizeLimit }));
-        app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
-    }
     var dataProvider;
     if (typeof options.dataProvider === "function") {
         dataProvider = options.dataProvider();
@@ -79,7 +70,7 @@ function remultExpress(options) {
         addArea: function (x) { return bridge.addArea(x); }
     });
 }
-exports.remultExpress = remultExpress;
+exports.remultMiddlewareBase = remultMiddlewareBase;
 var ExpressBridge = /** @class */ (function () {
     function ExpressBridge(app, queue, initRequest, dataProvider) {
         this.app = app;
@@ -93,11 +84,14 @@ var ExpressBridge = /** @class */ (function () {
     ExpressBridge.prototype.openApiDoc = function (options) {
         var e_1, _a, e_2, _b;
         var r = new __1.Remult();
+        if (!options.version)
+            options.version = "1.0.0";
         var spec = {
-            info: { title: options.title },
+            info: { title: options.title, version: options.version },
             openapi: "3.0.0",
             //swagger: "2.0",
             "components": {
+                "schemas": {},
                 "securitySchemes": {
                     "bearerAuth": {
                         "scheme": "bearer",
@@ -106,8 +100,7 @@ var ExpressBridge = /** @class */ (function () {
                     }
                 }
             },
-            paths: {},
-            definitions: {}
+            paths: {}
         };
         var validationError = {
             "400": {
@@ -115,7 +108,7 @@ var ExpressBridge = /** @class */ (function () {
                 "content": {
                     "application/json": {
                         "schema": {
-                            "$ref": "#/definitions/InvalidResponse"
+                            "$ref": "#/components/schemas/InvalidResponse"
                         }
                     }
                 }
@@ -182,12 +175,12 @@ var ExpressBridge = /** @class */ (function () {
                     }
                     finally { if (e_3) throw e_3.error; }
                 }
-                spec.definitions[key] = {
+                spec.components.schemas[key] = {
                     type: "object",
                     properties: properties
                 };
                 var definition = {
-                    "$ref": "#/definitions/" + key
+                    "$ref": "#/components/schemas/" + key
                 };
                 var secure = function (condition, def, item) {
                     item.tags = [meta.key];
@@ -206,28 +199,28 @@ var ExpressBridge = /** @class */ (function () {
                             "description": "limit the number of returned rows, default 100",
                             "required": false,
                             "style": "simple",
-                            "type": "int"
+                            "schema": { "type": "integer" }
                         },
                         {
                             "name": "_page",
                             "in": "query",
                             "description": "to be used for paging",
                             "required": false,
-                            "type": "int"
+                            "schema": { "type": "integer" }
                         },
                         {
                             "name": "_sort",
                             "in": "query",
                             "description": "the columns to sort on",
                             "required": false,
-                            "type": "string"
+                            "schema": { "type": "string" }
                         },
                         {
                             "name": "_order",
                             "in": "query",
                             "description": "the sort order to user for the columns in `_sort`",
                             "required": false,
-                            "type": "string"
+                            "schema": { "type": "string" }
                         }], parameters),
                     responses: {
                         "200": {
@@ -248,14 +241,14 @@ var ExpressBridge = /** @class */ (function () {
                     "in": "path",
                     "description": "id of " + key,
                     "required": true,
-                    "type": "string"
+                    "schema": { "type": "string" },
                 };
                 var itemInBody = {
                     "requestBody": {
                         "content": {
                             "application/json": {
                                 "schema": {
-                                    "$ref": "#/definitions/" + key
+                                    "$ref": "#/components/schemas/" + key
                                 }
                             }
                         }
@@ -269,7 +262,7 @@ var ExpressBridge = /** @class */ (function () {
                             "content": {
                                 "application/json": {
                                     "schema": {
-                                        "$ref": "#/definitions/" + key
+                                        "$ref": "#/components/schemas/" + key
                                     }
                                 }
                             }
@@ -282,7 +275,7 @@ var ExpressBridge = /** @class */ (function () {
                             "content": {
                                 "application/json": {
                                     "schema": {
-                                        "$ref": "#/definitions/" + key
+                                        "$ref": "#/components/schemas/" + key
                                     }
                                 }
                             }
@@ -299,7 +292,7 @@ var ExpressBridge = /** @class */ (function () {
                             "content": {
                                 "application/json": {
                                     "schema": {
-                                        "$ref": "#/definitions/" + key
+                                        "$ref": "#/components/schemas/" + key
                                     }
                                 }
                             }
@@ -378,7 +371,7 @@ var ExpressBridge = /** @class */ (function () {
             }
             finally { if (e_2) throw e_2.error; }
         }
-        spec.definitions["InvalidResponse"] = {
+        spec.components.schemas["InvalidResponse"] = {
             "type": "object",
             properties: {
                 "message": {

package/src/column-interfaces.d.ts

@@ -14,18 +14,18 @@ export interface FieldOptions<entityType = any, valueType = any> {
     allowApiUpdate?: AllowedForInstance<entityType>;
     /** An arrow function that'll be used to perform validations on it
      * @example
-     * .@Fields.string({
+     * @Fields.string({
      *   validate: Validators.required
      * })
      * @example
-     * .@Fields.string<Task>({
+     * @Fields.string<Task>({
      *    validate: task=>{
      *      if (task.title.length<3)
      *          throw "Too Short";
      *   }
      * })
      * @example
-     * .@Fields.string({
+     * @Fields.string({
      *    validate: (_, fieldRef)=>{
      *      if (fieldRef.value.length<3)
      *          fieldRef.error = "Too Short";

package/src/entity.d.ts

@@ -29,7 +29,7 @@ export interface EntityOptions<entityType = any> {
     apiPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
     /** A filter that will be used for all queries from this entity both from the API and from within the backend.
      * @example
-     * fixedWhereFilter: { archive:false }
+     * backendPrefilter: { archive:false }
      * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
      */
     backendPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
@@ -45,7 +45,7 @@ export interface EntityOptions<entityType = any> {
     * If the `error` property of the entity's ref or any of it's fields will be set, the save will be aborted and an exception will be thrown.
     * this is the place to run logic that we want to run in any case before an entity is saved.
     * @example
-    * .@Entity<Task>("tasks", {
+    * @Entity<Task>("tasks", {
     * saving: async task => {
     *      task.lastUpdated = new Date()
     *  }

package/src/remult3/RepositoryImplementation.d.ts

@@ -256,11 +256,11 @@ export declare function getValueList<T>(type: ClassType<T>): T[];
  * FieldOptions can be set in two ways:
  * @example
  * // as an object
- * .@Fields.string({ includeInApi:false })
+ * @Fields.string({ includeInApi:false })
  * title='';
  * @example
  * // as an arrow function that receives `remult` as a parameter
- * .@Fields.string((options,remult) => options.includeInApi = true)
+ * @Fields.string((options,remult) => options.includeInApi = true)
  * title='';
  */
 export declare function Field<entityType = any, valueType = any>(valueType: () => ClassType<valueType>, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
@@ -289,13 +289,14 @@ export declare function BuildEntity<entityType>(c: ClassType<entityType>, key: s
  *    @Fields.boolean()
  *    completed = false;
  * }
- * *EntityOptions can be set in two ways:*
+ * @note
+ * EntityOptions can be set in two ways:
  * @example
  * // as an object
- * .@Entity("tasks",{ allowApiCrud:true })
+ * @Entity("tasks",{ allowApiCrud:true })
  * @example
  * // as an arrow function that receives `remult` as a parameter
- * .@Entity("tasks", (options,remult) => options.allowApiCrud = true)
+ * @Entity("tasks", (options,remult) => options.allowApiCrud = true)
  */
 export declare function Entity<entityType>(key: string, ...options: (EntityOptions<entityType> | ((options: EntityOptions<entityType>, remult: Remult) => void))[]): (target: any) => any;
 export declare class EntityBase {

package/src/remult3/RepositoryImplementation.js

@@ -2467,11 +2467,11 @@ exports.getValueList = getValueList;
  * FieldOptions can be set in two ways:
  * @example
  * // as an object
- * .@Fields.string({ includeInApi:false })
+ * @Fields.string({ includeInApi:false })
  * title='';
  * @example
  * // as an arrow function that receives `remult` as a parameter
- * .@Fields.string((options,remult) => options.includeInApi = true)
+ * @Fields.string((options,remult) => options.includeInApi = true)
  * title='';
  */
 function Field(valueType) {
@@ -2637,13 +2637,14 @@ exports.BuildEntity = BuildEntity;
  *    @Fields.boolean()
  *    completed = false;
  * }
- * *EntityOptions can be set in two ways:*
+ * @note
+ * EntityOptions can be set in two ways:
  * @example
  * // as an object
- * .@Entity("tasks",{ allowApiCrud:true })
+ * @Entity("tasks",{ allowApiCrud:true })
  * @example
  * // as an arrow function that receives `remult` as a parameter
- * .@Entity("tasks", (options,remult) => options.allowApiCrud = true)
+ * @Entity("tasks", (options,remult) => options.allowApiCrud = true)
  */
 function Entity(key) {
     var options = [];

package/src/remult3/remult3.d.ts

@@ -112,7 +112,12 @@ export declare type OmitEB<T> = Omit<T, keyof import('./RepositoryImplementation
 export interface Repository<entityType> {
     /** returns a result array based on the provided options */
     find(options?: FindOptions<entityType>): Promise<entityType[]>;
-    /** returns the first item that matchers the `where` condition */
+    /** returns the first item that matchers the `where` condition
+     * @example
+     * await taskRepo.findFirst({ completed:false })
+     * @example
+     * await taskRepo.findFirst({ completed:false },{ createIfNotFound: true })
+     *      */
     findFirst(where?: EntityFilter<entityType>, options?: FindFirstOptions<entityType>): Promise<entityType>;
     /** returns the items that matches the idm the result is cached unless specified differently in the `options` parameter */
     findId(id: entityType extends {
@@ -285,7 +290,7 @@ export interface QueryResult<entityType> {
     [Symbol.asyncIterator](): {
         next: () => Promise<IteratorResult<entityType, entityType>>;
     };
-    /** returns the number of rows that match the query critiria */
+    /** returns the number of rows that match the query criteria */
     count(): Promise<number>;
     /** Returns a `Paginator` object that is used for efficient paging */
     paginator(): Promise<Paginator<entityType>>;
@@ -300,7 +305,7 @@ export interface Paginator<entityType> {
     items: entityType[];
     /** True if next page exists */
     hasNextPage: boolean;
-    /** Get's the next page in the query's result set */
+    /** Gets the next page in the `query`'s result set */
     nextPage(): Promise<Paginator<entityType>>;
     /** the count of the total items in the `query`'s result */
     count(): Promise<number>;