remult 0.17.3 → 0.18.0

package/src/buildRestDataProvider.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processHttpException = exports.toPromise = exports.retry = exports.HttpProviderBridgeToRestDataProviderHttpProvider = exports.isExternalHttpProvider = exports.buildRestDataProvider = void 0;
+var tslib_1 = require("tslib");
+var rest_data_provider_1 = require("./data-providers/rest-data-provider");
+function buildRestDataProvider(provider) {
+    if (!provider)
+        return new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch();
+    var httpDataProvider;
+    if (!httpDataProvider) {
+        if (isExternalHttpProvider(provider)) {
+            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
+        }
+    }
+    if (!httpDataProvider) {
+        if (typeof provider === "function") {
+            httpDataProvider = new rest_data_provider_1.RestDataProviderHttpProviderUsingFetch(provider);
+        }
+    }
+    return httpDataProvider;
+}
+exports.buildRestDataProvider = buildRestDataProvider;
+function isExternalHttpProvider(item) {
+    var http = item;
+    if (http && http.get && http.put && http.post && http.delete)
+        return true;
+    return false;
+}
+exports.isExternalHttpProvider = isExternalHttpProvider;
+var HttpProviderBridgeToRestDataProviderHttpProvider = /** @class */ (function () {
+    function HttpProviderBridgeToRestDataProviderHttpProvider(http) {
+        this.http = http;
+    }
+    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.post = function (url, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, retry(function () { return toPromise(_this.http.post(url, data)); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.delete = function (url) {
+        return toPromise(this.http.delete(url));
+    };
+    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.put = function (url, data) {
+        return toPromise(this.http.put(url, data));
+    };
+    HttpProviderBridgeToRestDataProviderHttpProvider.prototype.get = function (url) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, retry(function () { return toPromise(_this.http.get(url)); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return HttpProviderBridgeToRestDataProviderHttpProvider;
+}());
+exports.HttpProviderBridgeToRestDataProviderHttpProvider = HttpProviderBridgeToRestDataProviderHttpProvider;
+function retry(what) {
+    var _a, _b, _c, _d;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var err_1;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    if (!true) return [3 /*break*/, 7];
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 3, , 6]);
+                    return [4 /*yield*/, what()];
+                case 2: return [2 /*return*/, _e.sent()];
+                case 3:
+                    err_1 = _e.sent();
+                    if (!(((_a = err_1.message) === null || _a === void 0 ? void 0 : _a.startsWith("Error occurred while trying to proxy")) || ((_b = err_1.message) === null || _b === void 0 ? void 0 : _b.startsWith("Error occured while trying to proxy")) || ((_c = err_1.message) === null || _c === void 0 ? void 0 : _c.includes("http proxy error")) || ((_d = err_1.message) === null || _d === void 0 ? void 0 : _d.startsWith("Gateway Timeout")))) return [3 /*break*/, 5];
+                    return [4 /*yield*/, new Promise(function (res, req) {
+                            setTimeout(function () {
+                                res({});
+                            }, 250);
+                        })];
+                case 4:
+                    _e.sent();
+                    return [3 /*break*/, 0];
+                case 5: throw err_1;
+                case 6: return [3 /*break*/, 0];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.retry = retry;
+function toPromise(p) {
+    var _this = this;
+    var r;
+    if (p["toPromise"] !== undefined) {
+        r = p["toPromise"]();
+    }
+    //@ts-ignore
+    else
+        r = p;
+    return r.then(function (x) {
+        if (x && (x.status == 200 || x.status == 201) && x.headers && x.request && x.data) //for axios
+            return x.data;
+        return x;
+    }).catch(function (ex) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, processHttpException(ex)];
+                case 1: throw _a.sent();
+            }
+        });
+    }); });
+}
+exports.toPromise = toPromise;
+function processHttpException(ex) {
+    var _a, _b, _c;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var z, error, httpStatusCode, result;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, ex];
+                case 1:
+                    z = _d.sent();
+                    if (z.error)
+                        error = z.error;
+                    else if (z.isAxiosError) {
+                        if (typeof ((_a = z.response) === null || _a === void 0 ? void 0 : _a.data) === "string")
+                            error = z.response.data;
+                        else
+                            error = (_b = z === null || z === void 0 ? void 0 : z.response) === null || _b === void 0 ? void 0 : _b.data;
+                    }
+                    if (!error)
+                        error = z.message;
+                    if (z.status == 0 && z.error.isTrusted)
+                        error = "Network Error";
+                    if (typeof error === 'string') {
+                        error = {
+                            message: error,
+                        };
+                    }
+                    if (z.modelState)
+                        error.modelState = z.modelState;
+                    httpStatusCode = z.status;
+                    if (httpStatusCode === undefined)
+                        httpStatusCode = (_c = z.response) === null || _c === void 0 ? void 0 : _c.status;
+                    if (httpStatusCode !== undefined && httpStatusCode !== null) {
+                        error.httpStatusCode = httpStatusCode;
+                    }
+                    result = Object.assign(error, {
+                    //     exception: ex disabled for now because JSON.stringify crashed with this
+                    });
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+}
+exports.processHttpException = processHttpException;

package/src/column-interfaces.d.ts

@@ -2,7 +2,10 @@ import { ClassType } from '../classType';
 import { Allowed, AllowedForInstance } from './context';
 import { EntityMetadata, FieldRef } from './remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
-    /**A human readable name for the field */
+    /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
+    * @example
+    * <input placeholder={taskRepo.metadata.fields.title.caption}/>
+    */
     caption?: string;
     /** If it can store null in the database */
     allowNull?: boolean;
@@ -32,14 +35,23 @@ export interface FieldOptions<entityType = any, valueType = any> {
      *   }
      * })
      */
-    validate?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
+    validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, fieldRef: 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>));
+    saving?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>));
     /**  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 */
+    /** Used or fields that are based on an sql expressions, instead of a physical table column
+     * @example
+     *
+     * @Fields.integer({
+     *   sqlExpression:e=> 'length(title)'
+     * })
+     * titleLength = 0;
+     * @Fields.string()
+     * title='';
+    */
     sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
     /** For fields that shouldn't be part of an update or insert statement */
     dbReadOnly?: boolean;
@@ -62,18 +74,42 @@ export interface FieldOptions<entityType = any, valueType = any> {
     /** The key to be used for this field */
     key?: string;
 }
+/**Metadata for a `Field`, this metadata can be used in the user interface to provide a richer UI experience */
 export interface FieldMetadata<valueType = any> {
+    /** The field's member name in an object.
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * console.log(taskRepo.metadata.fields.title.key);
+     * // result: title
+     */
     readonly key: string;
-    readonly target: ClassType<valueType>;
-    readonly valueType: any;
+    /** A human readable caption for the field. Can be used to achieve a consistent caption for a field throughout the app
+     * @example
+     * <input placeholder={taskRepo.metadata.fields.title.caption}/>
+     */
     readonly caption: string;
+    /** The field's value type (number,string etc...) */
+    readonly valueType: any;
+    /** The options sent to this field's decorator */
+    readonly options: FieldOptions;
+    /** The `inputType` relevant for this field, determined by the options sent to it's decorator and the valueConverter in these options */
     readonly inputType: string;
+    /** if null is allowed for this field */
     readonly allowNull: boolean;
+    /** The class that contains this field
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * Task == taskRepo.metadata.fields.title.target //will return true
+    */
+    readonly target: ClassType<valueType>;
+    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
+    /** Indicates if this field is based on a server express */
     readonly isServerExpression: boolean;
+    /** indicates that this field should only be included in select statement, and excluded from update or insert. useful for db generated ids etc... */
     readonly dbReadOnly: boolean;
+    /** the Value converter for this field */
     readonly valueConverter: ValueConverter<valueType>;
-    readonly options: FieldOptions;
 }
 export interface ValueConverter<valueType> {
     fromJson?(val: any): valueType;
@@ -86,7 +122,7 @@ export interface ValueConverter<valueType> {
     readonly fieldTypeInDb?: string;
     readonly inputType?: string;
 }
-export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, col: FieldRef<entityType, valueType>) => void | Promise<void>;
+export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => void | Promise<void>;
 export declare type ValueOrExpression<valueType> = valueType | (() => valueType);
 export declare function valueOrExpressionToValue<valueType>(f: ValueOrExpression<valueType>): valueType;
 export interface ValueListItem {

package/src/column.d.ts

@@ -1,7 +1,7 @@
 import { ClassType } from '../classType';
 import { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
 import { Filter } from './filter/filter-interfaces';
-import { EntityFilter, FindOptions, Repository, RepositoryImplementation } from './remult3';
+import { EntityFilter, FindOptions, idType, Repository, RepositoryImplementation } from './remult3';
 export declare function makeTitle(name: string): string;
 export declare class CompoundIdField implements FieldMetadata<string> {
     fields: FieldMetadata[];
@@ -25,12 +25,12 @@ export declare class CompoundIdField implements FieldMetadata<string> {
 }
 export declare class LookupColumn<T> {
     private repository;
-    id: string;
+    id: idType<T>;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
     get(id: any): any;
     set(item: T): void;
-    constructor(repository: RepositoryImplementation<T>, id: string);
+    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
     get item(): T;
     waitLoad(): Promise<T>;
 }

package/src/context.d.ts

@@ -1,43 +1,20 @@
-import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
-import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+import { DataProvider } from "./data-interfaces";
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-export interface ExternalHttpProvider {
-    post(url: string, data: any): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-    delete(url: string): Promise<void> | {
-        toPromise(): Promise<void>;
-    };
-    put(url: string, data: any): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-    get(url: string): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-}
-export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
-    private http;
-    constructor(http: ExternalHttpProvider);
-    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>;
+import type { SubscriptionServer } from "./live-query/SubscriptionServer";
+import { ExternalHttpProvider } from "./buildRestDataProvider";
+import { SubscriptionClient } from "./live-query/SubscriptionChannel";
 export declare function isBackend(): boolean;
 export declare class Remult {
     /**Return's a `Repository` of the specific entity type
      * @example
      * const taskRepo = remult.repo(Task);
      * @see [Repository](https://remult.dev/docs/ref_repository.html)
-     *
+     * @param entity - the entity to use
+     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
      */
     repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    /** Returns the current user's info */
     user?: UserInfo;
     /** Checks if a user was authenticated */
     authenticated(): boolean;
@@ -53,6 +30,8 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
+    /** The current data provider */
+    dataProvider: DataProvider;
     /** 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.
@@ -62,23 +41,42 @@ export declare class Remult {
     constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
     constructor(p: DataProvider);
     constructor();
+    subscriptionServer?: SubscriptionServer;
+    /** Used to call a `backendMethod` using a specific `remult` object
+     * @example
+     * await remult.call(TasksController.setAll, undefined, true);
+     * @param backendMethod - the backend method to call
+     * @param classInstance - the class instance of the backend method, for static backend methods use undefined
+     * @param args - the arguments to send to the backend method
+    */
     call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
-    /** The current data provider */
-    dataProvider: DataProvider;
     /** 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;
+    /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
     readonly context: RemultContext;
+    /** The api client that will be used by `remult` to perform calls to the `api` */
     apiClient: ApiClient;
 }
 export declare type GetArguments<T> = T extends (...args: infer FirstArgument) => any ? FirstArgument : never;
 export interface RemultContext {
 }
 export interface ApiClient {
+    /** The http client to use when making api calls.
+     * @example
+     * remult.apiClient.httpClient = axios;
+     * @example
+     * remult.apiClient.httpClient = httpClient;//angular http client
+     * @example
+     * remult.apiClient.httpClient = fetch; //this is the default
+     */
     httpClient?: ExternalHttpProvider | typeof fetch;
+    /** The base url to for making api calls */
     url?: string;
+    subscriptionClient?: SubscriptionClient;
+    wrapMessageHandling?: (x: VoidFunction) => void;
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {
@@ -88,18 +86,17 @@ export declare const classHelpers: Map<any, ClassHelper>;
 export declare class ClassHelper {
     classes: Map<any, ControllerOptions>;
 }
-export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProvider | RestDataProviderHttpProviderUsingFetch;
 export declare function setControllerSettings(target: any, options: ControllerOptions): void;
 export interface UserInfo {
     id: string;
     name?: string;
     roles?: string[];
 }
-export declare type Allowed = boolean | string | string[] | ((c: Remult) => boolean);
-export declare type AllowedForInstance<T> = boolean | string | string[] | ((c: Remult, entity?: T) => boolean);
+export declare type Allowed = boolean | string | string[] | ((c?: Remult) => boolean);
+export declare type AllowedForInstance<T> = boolean | string | string[] | ((entity?: T, c?: Remult) => boolean);
 export declare class Allow {
     static everyone: () => boolean;
-    static authenticated: (remult: Remult) => boolean;
+    static authenticated: (...args: any[]) => any;
 }
 export declare const queryConfig: {
     defaultPageSize: number;
@@ -113,3 +110,9 @@ export declare class EventSource {
     fire(): Promise<void>;
     dispatcher: EventDispatcher;
 }
+export interface itemChange {
+    id: any;
+    oldId: any;
+    deleted: boolean;
+}
+export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;