remult 0.13.19 → 0.13.22

package/graphql.js

@@ -98,15 +98,15 @@ function remultGraphql(api) {
             root[key] = function (_a, req) {
                 var options = _a.options, filter = _a.filter;
                 return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var remult, repo, dapi, result, err;
+                    var remult, repo, dApi, result, err;
                     return tslib_1.__generator(this, function (_b) {
                         switch (_b.label) {
                             case 0: return [4 /*yield*/, api.getRemult(req)];
                             case 1:
                                 remult = _b.sent();
                                 repo = remult.repo(e);
-                                dapi = new data_api_1.DataApi(repo, remult);
-                                return [4 /*yield*/, dapi.getArray({
+                                dApi = new data_api_1.DataApi(repo, remult);
+                                return [4 /*yield*/, dApi.getArray({
                                         success: function (x) { return result = x; },
                                         created: undefined,
                                         deleted: undefined,

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "remult",
-    "version": "0.13.19",
-    "description": "remult core lib",
+    "version": "0.13.22",
+    "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev/",
     "repository": {
         "type": "git",

package/readme.md

@@ -27,7 +27,7 @@
 
 ## What is Remult?
 
-**Remult** is a fullstack CRUD framework that uses your TypeScript model types to provide:
+**Remult** is a full-stack CRUD framework that uses your TypeScript model types to provide:
 
 * Secure REST API (highly configurable)
 * Type-safe frontend API client
@@ -38,13 +38,18 @@
 Using a `monorepo` approach, with model types shared between frontend and backend code, Remult can enforce data validation and constraints, defined once, on both frontend and REST API levels.
 
 ## Getting started
-The best way to learn Remult is by following a tutorial of a simple Todo app with a Node.js Express backend. There's one [using a React frontend](https://remult.dev/tutorials/tutorial-react.html) and one [using Angular](https://remult.dev/tutorials/tutorial-angular.html).
+The best way to learn Remult is by following a tutorial of a simple Todo web app with a Node.js Express backend. 
+
+* [Tutorial with React](https://remult.dev/tutorials/react/) 
+* [Tutorial with Angular](https://remult.dev/tutorials/tutorial-angular.html)
 
 ## Installation
 ```sh
 npm i remult
 ```
 
+## Usage
+
 ### Setup API backend using a Node.js Express middleware
 ```ts
 import express from 'express';
@@ -60,14 +65,14 @@ app.listen(port, () => {
 });
 ```
 
-## Define model classes
+### Define model classes
 ```ts
-import { Entity, EntityBase, Fields } from 'remult';
+import { Entity, Fields } from 'remult';
 
 @Entity('products', {
     allowApiCrud: true
 })
-export class Product extends EntityBase {
+export class Product {
   @Fields.string()
   name = '';
 
@@ -83,13 +88,14 @@ export class Product extends EntityBase {
 [{"name":"Tofu","unitPrice":5}]
 ```
 
-## Find and manipulate data in type-safe frontend code
+### Find and manipulate data in type-safe frontend code
 ```ts
 async function increasePriceOfTofu(priceIncrease: number) {
-  const product = await remult.repo(Product).findFirst({ name: 'Tofu' });
+  const productsRepo = remult.repo(Product);
 
+  const product = await productsRepo.findFirst({ name: 'Tofu' });
   product.unitPrice += priceIncrease;
-  product.save();
+  productsRepo.save(product);
 }
 ```
 
@@ -97,22 +103,23 @@ async function increasePriceOfTofu(priceIncrease: number) {
 ```ts
 @BackendMethod({ allowed: Allow.authenticated })
 static async increasePriceOfTofu(priceIncrease: number, remult?: Remult) {
-  const product = await remult!.repo(Product).findFirst({ name: 'Tofu' });
+  const productsRepo = remult!.repo(Product);
 
+  const product = await productsRepo.findFirst({ name: 'Tofu' });
   product.unitPrice += priceIncrease;
-  product.save();
+  productsRepo.save(product);
 }
 ```
 
-## :ballot_box_with_check: Data validation and constraints - defined once
+### :ballot_box_with_check: Data validation and constraints - defined once
 
 ```ts
-import { Entity, EntityBase, Fields } from 'remult';
+import { Entity, Fields } from 'remult';
 
 @Entity('products', {
     allowApiCrud: true
 })
-export class Product extends EntityBase {
+export class Product {
     @Fields.string<Product>({
         validate: product => {
             if (product.name.trim().length == 0)
@@ -133,13 +140,13 @@ export class Product extends EntityBase {
 
 ### Enforced in frontend:
 ```ts
-const product = remult.repo(Product).create();
+const product = productsRepo.create();
 
 try {
-  await product.save();
+  await productsRepo.save(product);
 }
-catch {
-  console.error(product._.error); // Browser console will display - "Name: required"
+catch (e: ErrorInfo<Product>) {
+  console.error(e.message); // Browser console will display - "Name: required"
 }
 ```
 
@@ -150,14 +157,14 @@ catch {
 {"modelState":{"unitPrice":"must not be less than 0","name":"required"},"message":"Name: required"}
 ```
 
-## :lock: Secure the API with fine-grained authorization
+### :lock: Secure the API with fine-grained authorization
 ```ts
 @Entity<Article>('Articles', {
     allowApiRead: true,
     allowApiInsert: remult => remult.authenticated(),
     allowApiUpdate: (remult, article) => article.author.id == remult.user.id
 })
-export class Article extends EntityBase {
+export class Article {
     @Fields.string({ allowApiUpdate: false })
     slug = '';
     
@@ -168,3 +175,9 @@ export class Article extends EntityBase {
     content = '';
 }
 ```
+
+## Contributing
+Contributions are welcome. See [CONTRIBUTING](CONTRIBUTING.md).
+
+## License
+Remult is [MIT Licensed](LICENSE).

package/server/expressBridge.d.ts

@@ -6,10 +6,10 @@ import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
 import { AllowedForInstance } from '../src/context';
 import { ClassType } from '../classType';
 export declare function remultExpress(options?: {
-    /** Determines the Data Provider
-  
-  * @see  [Optional Databases](https://remult.dev/docs/databases.html)
-  */
+    /** 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;

package/server/expressBridge.js

@@ -453,6 +453,8 @@ var SiteArea = /** @class */ (function () {
                         _b.apply(_a, [_c.sent()]);
                         if (req) {
                             user = req['user'];
+                            if (!user)
+                                user = req['auth'];
                             if (user)
                                 remult.setUser(user);
                         }

package/src/column-interfaces.d.ts

@@ -2,24 +2,65 @@ import { ClassType } from '../classType';
 import { Allowed, AllowedForInstance } from './context';
 import { EntityMetadata, FieldRef } from './remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
-    key?: string;
-    target?: ClassType<entityType>;
-    valueType?: any;
+    /**A human readable name for the field */
     caption?: string;
-    displayValue?: (entity: entityType, value: valueType) => string;
-    defaultValue?: (entity: entityType) => valueType | Promise<valueType>;
+    /** If it can store null in the database */
+    allowNull?: boolean;
+    /** If this field data is included in the api.
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    includeInApi?: Allowed;
+    /** If this field data can be updated in the api.
+    * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    allowApiUpdate?: AllowedForInstance<entityType>;
+    /** An arrow function that'll be used to perform validations on it
+     * @example
+     * .@Fields.string({
+     *   validate: Validators.required
+     * })
+     * @example
+     * .@Fields.string<Task>({
+     *    validate: task=>{
+     *      if (task.title.length<3)
+     *          throw "Too Short";
+     *   }
+     * })
+     * @example
+     * .@Fields.string({
+     *    validate: (_, fieldRef)=>{
+     *      if (fieldRef.value.length<3)
+     *          fieldRef.error = "Too Short";
+     *   }
+     * })
+     */
     validate?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
+    /** Will be fired before this field is saved to the server/database */
     saving?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>));
-    inputType?: string;
-    allowNull?: boolean;
+    /**  An expression that will determine this fields value on the backend and be provided to the front end*/
+    serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
+    /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead. */
     dbName?: string;
+    /** Used or fields that are based on an sql expressions, instead of a physical table column */
     sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
-    serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
+    /** For fields that shouldn't be part of an update or insert statement */
     dbReadOnly?: boolean;
+    /** The value converter to be used when loading and saving this field */
     valueConverter?: ValueConverter<valueType>;
-    includeInApi?: Allowed;
-    allowApiUpdate?: AllowedForInstance<entityType>;
+    /** an arrow function that translates the value to a display value */
+    displayValue?: (entity: entityType, value: valueType) => string;
+    /** an arrow function that determines the default value of the field, when the entity is created using the `repo.create` method */
+    defaultValue?: (entity: entityType) => valueType | Promise<valueType>;
+    /** The html input type for this field */
+    inputType?: string;
+    /** Determines if the referenced entity will be loaded immediately or on demand.
+     * @see[Lazy loading of related entities](http://remult.dev/docs/lazy-loading-of-related-entities.html)
+     */
     lazy?: boolean;
+    /** The value type for this field */
+    valueType?: any;
+    /** The entity type to which this field belongs */
+    target?: ClassType<entityType>;
+    /** The key to be used for this field */
+    key?: string;
 }
 export interface FieldMetadata<valueType = any> {
     readonly key: string;

package/src/column.d.ts

@@ -44,7 +44,6 @@ export declare class OneToMany<T> {
     private _currentPromise;
     get lazyItems(): T[];
     load(): Promise<T[]>;
-    reload(): Promise<T[]>;
     private find;
     create(item?: Partial<T>): T;
 }

package/src/column.js

@@ -131,8 +131,6 @@ var OneToMany = /** @class */ (function () {
     function OneToMany(provider, settings) {
         this.provider = provider;
         this.settings = settings;
-        if (!this.settings)
-            this.settings = {};
     }
     Object.defineProperty(OneToMany.prototype, "lazyItems", {
         get: function () {
@@ -159,14 +157,6 @@ var OneToMany = /** @class */ (function () {
             });
         });
     };
-    OneToMany.prototype.reload = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                this._currentPromise = undefined;
-                return [2 /*return*/, this.load()];
-            });
-        });
-    };
     OneToMany.prototype.find = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
@@ -178,8 +168,6 @@ var OneToMany = /** @class */ (function () {
         var r = this.provider.create();
         remult3_1.__updateEntityBasedOnWhere(this.provider.metadata, this.settings.where, r);
         assign_1.assign(r, item);
-        if (this.settings.create)
-            this.settings.create(r);
         return r;
     };
     return OneToMany;

package/src/context.d.ts

@@ -1,4 +1,4 @@
-import { DataProvider } from "./data-interfaces";
+import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
 export interface HttpProvider {
@@ -15,33 +15,76 @@ export interface HttpProvider {
         toPromise(): Promise<any>;
     };
 }
+export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
+    private http;
+    constructor(http: HttpProvider);
+    post(url: string, data: any): Promise<any>;
+    delete(url: string): Promise<void>;
+    put(url: string, data: any): Promise<any>;
+    get(url: string): Promise<any>;
+}
+export declare function retry<T>(what: () => Promise<T>): Promise<T>;
 export declare function toPromise<T>(p: Promise<T> | {
     toPromise(): Promise<T>;
 }): Promise<any>;
 export declare function processHttpException(ex: any): Promise<any>;
 export declare function isBackend(): boolean;
 export declare class Remult {
-    static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
-    clearAllCache(): any;
-    static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
-    authenticated(): boolean;
-    constructor(provider?: HttpProvider | DataProvider);
-    _dataSource: DataProvider;
-    setDataProvider(dataProvider: DataProvider): void;
-    protected _user: UserInfo;
+    /**Return's a `Repository` of the specific entity type
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * @see [Repository](https://remult.dev/docs/ref_repository.html)
+     *
+     */
+    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    /** Returns the current user's info */
     get user(): UserInfo;
-    private _userChangeEvent;
-    get userChange(): EventDispatcher;
+    /** Set's the current user info */
     setUser(info: UserInfo | {
         sub?: string;
         name?: string;
         permissions?: string[];
     }): Promise<void>;
-    static apiBaseUrl: string;
-    isAllowedForInstance(instance: any, x: AllowedForInstance<any>): boolean;
+    private _user;
+    private _userChangeEvent;
+    /** Checks if a user was authenticated */
+    authenticated(): boolean;
+    /** checks if the user has any of the roles specified in the parameters
+     * @example
+     * remult.isAllowed("admin")
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
     isAllowed(roles: Allowed): boolean;
+    /** checks if the user matches the allowedForInstance callback
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
+    isAllowedForInstance(instance: any, x: AllowedForInstance<any>): boolean;
+    /** returns a dispatcher object that fires once a user has changed*/
+    get userChange(): EventDispatcher;
     private repCache;
-    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    /** Creates a new instance of the `remult` object.
+     *
+     * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
+     *
+     * If no provider is specified, `fetch` will be used as an http provider
+     */
+    constructor(provider?: HttpProvider | DataProvider);
+    /** The api Base Url to be used in all remult calls. by default it's set to `/api`.
+     *
+     * Set this property in case you want to determine a non relative api url
+     */
+    static apiBaseUrl: string;
+    /** The current data provider */
+    _dataSource: DataProvider;
+    /** sets the current data provider */
+    setDataProvider(dataProvider: DataProvider): void;
+    /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
+    static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
+    clearAllCache(): any;
+    /** A helper callback that is called whenever an entity is created. */
+    static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {