remult 0.13.19 → 0.13.22

package/src/remult3/remult3.d.ts

@@ -42,7 +42,7 @@ export interface Subscribable {
 }
 export declare type FieldsRef<entityType> = {
     [Properties in keyof OmitEB<entityType>]: entityType[Properties] extends {
-        id: (number | string);
+        id?: (number | string);
     } ? IdFieldRef<entityType, entityType[Properties]> : FieldRef<entityType, entityType[Properties]>;
 } & {
     find(fieldMetadataOrKey: FieldMetadata | string): FieldRef<entityType, any>;
@@ -63,10 +63,15 @@ export declare type SortSegments<entityType> = {
 };
 export interface IdFieldRef<entityType, valueType> extends FieldRef<entityType, valueType> {
     setId(id: valueType extends {
-        id: number;
+        id?: number;
     } ? number : valueType extends {
-        id: string;
+        id?: string;
     } ? string : (string | number)): any;
+    getId(): (valueType extends {
+        id?: number;
+    } ? number : valueType extends {
+        id?: string;
+    } ? string : (string | number));
 }
 export interface FieldRef<entityType = any, valueType = any> extends Subscribable {
     error: string;
@@ -77,7 +82,7 @@ export interface FieldRef<entityType = any, valueType = any> extends Subscribabl
     valueChanged(): boolean;
     entityRef: EntityRef<entityType>;
     container: entityType;
-    metadata: FieldMetadata<entityType>;
+    metadata: FieldMetadata<valueType>;
     load(): Promise<valueType>;
     valueIsNull(): boolean;
     originalValueIsNull(): boolean;
@@ -103,43 +108,80 @@ export interface EntityMetadata<entityType = any> {
     getDbName(): Promise<string>;
 }
 export declare type OmitEB<T> = Omit<T, keyof import('./RepositoryImplementation').EntityBase>;
+/**used to perform CRUD operations on an `entityType` */
 export interface Repository<entityType> {
-    /**creates a json representation of the object */
-    fromJson(x: any, isNew?: boolean): Promise<entityType>;
-    metadata: EntityMetadata<entityType>;
     /** returns a result array based on the provided options */
     find(options?: FindOptions<entityType>): Promise<entityType[]>;
-    query(options?: QueryOptions<entityType>): QueryResult<entityType>;
+    /** returns the first item that matchers the `where` condition */
     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 {
-        id: number;
+        id?: number;
     } ? number : entityType extends {
-        id: string;
+        id?: string;
     } ? string : (string | number), options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
+    /**  An alternative form of fetching data from the API server, which is intended for operating on large numbers of entity objects.
+     *
+     * It also has it's own paging mechanism that can be used n paging scenarios.
+     *
+     * The `query` method doesn't return an array (as the `find` method) and instead returns an `iteratable` `QueryResult` object
+     * which supports iterations using the JavaScript `for await` statement.
+     * @example
+     * for await (const task of taskRepo.query()) {
+     *   // do something.
+     * }
+     * */
+    query(options?: QueryOptions<entityType>): QueryResult<entityType>;
+    /** Returns a count of the items matching the criteria.
+     * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
+     * @example
+     * await taskRepo.count({ completed:false })
+     */
     count(where?: EntityFilter<entityType>): Promise<number>;
-    create(item?: Partial<OmitEB<entityType>>): entityType;
-    getEntityRef(item: entityType): EntityRef<entityType>;
+    /** saves an item or item[] to the data source. It assumes that if an `id` value exists, it's an existing row - otherwise it's a new row
+     * @example
+     * await taskRepo.save({...task, completed:true })
+    */
     save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     save(item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    /**Insert an item or item[] to the data source
+     * @example
+     * await taskRepo.insert({title:"task a"})
+     * @example
+     * await taskRepo.insert([{title:"task a"}, {title:"task b", completed:true }])
+    */
     insert(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     insert(item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    /** Updates an item, based on it's `id`
+     * @example
+     * taskRepo.update(task.id,{...task,completed:true})
+    */
     update(id: (entityType extends {
-        id: number;
+        id?: number;
     } ? number : entityType extends {
-        id: string;
+        id?: string;
     } ? string : (string | number)), item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    /** Deletes an Item*/
     delete(id: (entityType extends {
-        id: number;
+        id?: number;
     } ? number : entityType extends {
-        id: string;
+        id?: string;
     } ? string : (string | number))): Promise<void>;
     delete(item: entityType): Promise<void>;
+    /** Creates an instance of an item. It'll not be saved to the data source unless `save` or `insert` will be called for that item */
+    create(item?: Partial<OmitEB<entityType>>): entityType;
+    /** Translates a json object to an item instance */
+    fromJson(x: any, isNew?: boolean): Promise<entityType>;
+    /** returns an `entityRef` for an item returned by `create`, `find` etc... */
+    getEntityRef(item: entityType): EntityRef<entityType>;
+    /**The metadata for the `entity` */
+    metadata: EntityMetadata<entityType>;
     addEventListener(listener: entityEventListener<entityType>): Unobserve;
 }
 export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
     /** Determines the number of rows returned by the request, on the browser the default is 100 rows
      * @example
-     * this.products = await this.remult.repo(Products).find({
+     * await this.remult.repo(Products).find({
      *  limit:10,
      *  page:2
      * })
@@ -147,27 +189,28 @@ export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
     limit?: number;
     /** Determines the page number that will be used to extract the data
      * @example
-     * this.products = await this.remult.repo(Products).find({
+     * await this.remult.repo(Products).find({
      *  limit:10,
      *  page:2
      * })
     */
     page?: number;
 }
-/** Determines the order of rows returned by the query.
+/** Determines the order of items returned .
  * @example
  * await this.remult.repo(Products).find({ orderBy: { name: "asc" }})
  * @example
- * await this.remult.repo(Products).find({ orderBy: { price: "asc", name: "asc" }})
- * @example
  * await this.remult.repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
  */
 export declare type EntityOrderBy<entityType> = {
     [Properties in keyof Partial<OmitEB<entityType>>]?: "asc" | "desc";
 };
+/**Used to filter the desired result set
+ * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
+ */
 export declare type EntityFilter<entityType> = {
     [Properties in keyof Partial<OmitEB<entityType>>]?: (Partial<OmitEB<entityType>>[Properties] extends (number | Date | undefined) ? ComparisonValueFilter<Partial<OmitEB<entityType>>[Properties]> : Partial<OmitEB<entityType>>[Properties] extends (string | undefined) ? ContainsStringValueFilter & ComparisonValueFilter<string> : Partial<OmitEB<entityType>>[Properties] extends (boolean | undefined) ? ValueFilter<boolean> : Partial<OmitEB<entityType>>[Properties] extends ({
-        id: (string | number);
+        id?: (string | number);
     } | undefined) ? IdFilter<Partial<OmitEB<entityType>>[Properties]> : ValueFilter<Partial<OmitEB<entityType>>[Properties]>) & ContainsStringValueFilter;
 } & {
     $or?: EntityFilter<entityType>[];
@@ -192,7 +235,7 @@ export interface ContainsStringValueFilter {
 }
 export declare type IdFilter<valueType> = ValueFilter<valueType> | {
     $id: ValueFilter<valueType extends {
-        id: number;
+        id?: number;
     } ? number : string>;
 };
 export interface LoadOptions<entityType> {
@@ -201,41 +244,64 @@ export interface LoadOptions<entityType> {
 export interface FindOptionsBase<entityType> extends LoadOptions<entityType> {
     /** filters the data
     * @example
-    * where p => p.price.isGreaterOrEqualTo(5)
-    * @see For more usage examples see [EntityWhere](https://remult-ts.github.io/guide/ref_entitywhere)
+    * await taskRepo.find({where: { completed:false }})
+    * @see For more usage examples see [EntityFilter](https://remult.dev/docs/entityFilter.html)
     */
     where?: EntityFilter<entityType>;
-    /** Determines the order in which the result will be sorted in
-     * @see See [EntityOrderBy](https://remult-ts.github.io/guide/ref__entityorderby) for more examples on how to sort
-     */
+    /** Determines the order of items returned .
+    * @example
+    * await this.remult.repo(Products).find({ orderBy: { name: "asc" }})
+    * @example
+    * await this.remult.repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
+    */
     orderBy?: EntityOrderBy<entityType>;
 }
 export interface FindFirstOptions<entityType> extends FindOptionsBase<entityType>, FindFirstOptionsBase<entityType> {
 }
 export interface FindFirstOptionsBase<entityType> extends LoadOptions<entityType> {
-    /** default true
+    /** determines if to cache the result, and return the results from cache.
       */
     useCache?: boolean;
+    /** If set to true and an item is not found, it's created and returned*/
     createIfNotFound?: boolean;
 }
 export interface QueryOptions<entityType> extends FindOptionsBase<entityType> {
+    /** The number of items to return in each step */
     pageSize?: number;
+    /** A callback method to indicate the progress of the iteration */
     progress?: {
         progress: (progress: number) => void;
     };
 }
+/** The result of a call to the `query` method in the `Repository` object.
+ */
 export interface QueryResult<entityType> {
-    getPage(pageNumber?: number): Promise<entityType[]>;
-    count(): Promise<number>;
-    forEach(what: (item: entityType) => Promise<any>): Promise<number>;
-    paginator(): Promise<Paginator<entityType>>;
+    /** returns an iterator that iterates the rows in the result using a paging mechanism
+     * @example
+     * for await (const task of taskRepo.query()) {
+     *   await taskRepo.save({ ...task, completed });
+     * }
+    */
     [Symbol.asyncIterator](): {
         next: () => Promise<IteratorResult<entityType, entityType>>;
     };
+    /** returns the number of rows that match the query critiria */
+    count(): Promise<number>;
+    /** Returns a `Paginator` object that is used for efficient paging */
+    paginator(): Promise<Paginator<entityType>>;
+    /** gets the items in a specific page */
+    getPage(pageNumber?: number): Promise<entityType[]>;
+    /** Performs an operation on all the items matching the query criteria */
+    forEach(what: (item: entityType) => Promise<any>): Promise<number>;
 }
+/** An interface used to paginating using the `query` method in the `Repository` object */
 export interface Paginator<entityType> {
+    /** the items in the current page */
     items: entityType[];
-    count(): Promise<number>;
+    /** True if next page exists */
     hasNextPage: boolean;
+    /** Get's 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>;
 }

package/src/server-action.d.ts

@@ -27,9 +27,12 @@ export declare class myServerAction extends Action<inArgs, result> {
     protected execute(info: inArgs, remult: Remult, res: DataApiResponse): Promise<result>;
 }
 export interface BackendMethodOptions<type> {
+    /**Determines when this `BackendMethod` can execute, see: [Allowed](https://remult.dev/docs/allowed.html)  */
     allowed: AllowedForInstance<type>;
-    blockUser?: boolean;
+    /** EXPERIMENTAL: Determines if this method should be queued for later execution */
     queue?: boolean;
+    /** EXPERIMENTAL: Determines if the user should be blocked while this `BackendMethod` is running*/
+    blockUser?: boolean;
 }
 export declare const actionInfo: {
     allActions: any[];
@@ -42,6 +45,7 @@ export declare const actionInfo: {
 };
 export declare const serverActionField: unique symbol;
 export declare function Controller(key: string): (target: any) => any;
+/** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
 export declare function BackendMethod<type = any>(options: BackendMethodOptions<type>): (target: any, key: string, descriptor: any) => any;
 export interface registrableAction {
     __register: (reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: DataApiRequest, res: DataApiResponse) => void)) => void) => void;

package/src/server-action.js

@@ -178,6 +178,7 @@ function Controller(key) {
     };
 }
 exports.Controller = Controller;
+/** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
 function BackendMethod(options) {
     return function (target, key, descriptor) {
         if (target.prototype !== undefined) {

package/src/shared-tests/db-tests.db-tests.js

@@ -218,7 +218,58 @@ db_tests_setup_1.testAll("empty find works", function (_a) {
             }
         });
     });
-});
+}, false);
+db_tests_setup_1.testAll("test descending", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, rows;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    repo = _b.sent();
+                    return [4 /*yield*/, repo.create({ id: 1, categoryName: 'a' }).save()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, repo.create({ id: 2, categoryName: 'b' }).save()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, repo.find({
+                            orderBy: { categoryName: 'desc' },
+                            page: -1
+                        })];
+                case 4:
+                    rows = _b.sent();
+                    expect(rows[0].id).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("test descending 2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, rows;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    repo = _b.sent();
+                    return [4 /*yield*/, repo.insert([{ id: 1, categoryName: 'a' }, { id: 2, categoryName: 'b' }])];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, repo.find({
+                            orderBy: { categoryName: 'desc' },
+                            page: -1
+                        })];
+                case 3:
+                    rows = _b.sent();
+                    expect(rows[0].id).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
 db_tests_setup_1.testAll("partial updates", function (_a) {
     var remult = _a.remult, createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {

package/src/shared-tests/entityWithValidations.js

@@ -64,26 +64,12 @@ var entityWithValidations = /** @class */ (function (_super) {
         remult3_1.Entity('', {
             allowApiCrud: true,
             saving: function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-                var e;
                 return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!t.name || t.name.length < 3)
-                                t._.fields.name.error = 'invalid';
-                            if (!(t._.isNew() && (!t.myId || t.myId == 0))) return [3 /*break*/, 2];
-                            return [4 /*yield*/, t.remult.repo(entityWithValidations_1).find({
-                                    orderBy: { myId: "desc" },
-                                    limit: 1
-                                })];
-                        case 1:
-                            e = _a.sent();
-                            t.myId = e.length ? e[0].myId + 1 : 1;
-                            _a.label = 2;
-                        case 2:
-                            if (!exports.testConfiguration.restDbRunningOnServer)
-                                entityWithValidations_1.savingRowCount++;
-                            return [2 /*return*/];
-                    }
+                    if (!t.name || t.name.length < 3)
+                        t._.fields.name.error = 'invalid';
+                    if (!exports.testConfiguration.restDbRunningOnServer)
+                        entityWithValidations_1.savingRowCount++;
+                    return [2 /*return*/];
                 });
             }); }
         }),

package/src/tests/TestDataApiResponse.js

@@ -7,22 +7,22 @@ var TestDataApiResponse = /** @class */ (function () {
     TestDataApiResponse.prototype.progress = function (progress) {
     };
     TestDataApiResponse.prototype.success = function (data) {
-        fail('didnt expect success: ' + JSON.stringify(data));
+        throw new Error(('didnt expect success: ' + JSON.stringify(data)));
     };
     TestDataApiResponse.prototype.forbidden = function () {
-        fail('didnt expect forbidden:');
+        throw new Error('didnt expect forbidden:');
     };
     TestDataApiResponse.prototype.created = function (data) {
-        fail('didnt expect created: ' + JSON.stringify(data));
+        throw new Error('didnt expect created: ' + JSON.stringify(data));
     };
     TestDataApiResponse.prototype.deleted = function () {
-        fail('didnt expect deleted:');
+        throw new Error('didnt expect deleted:');
     };
     TestDataApiResponse.prototype.notFound = function () {
-        fail('not found');
+        throw new Error('not found');
     };
     TestDataApiResponse.prototype.error = function (data) {
-        fail('error: ' + data + " " + JSON.stringify(data));
+        throw new Error('error: ' + data + " " + JSON.stringify(data));
     };
     return TestDataApiResponse;
 }());

package/src/tests/d.d.ts

@@ -3,5 +3,4 @@ export declare class d extends EntityBase {
     id: number;
     b: number;
     static count: number;
-    doIt(): Promise<boolean>;
 }

package/src/tests/d.js

@@ -2,22 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.d = void 0;
 var tslib_1 = require("tslib");
-var server_action_1 = require("../server-action");
 var remult3_1 = require("../remult3");
-var dWithPrefilter_1 = require("./dWithPrefilter");
 var d = /** @class */ (function (_super) {
     tslib_1.__extends(d, _super);
     function d() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    d.prototype.doIt = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                dWithPrefilter_1.dWithPrefilter.count++;
-                return [2 /*return*/, true];
-            });
-        });
-    };
     d.count = 0;
     tslib_1.__decorate([
         remult3_1.Fields.integer(),
@@ -27,12 +17,6 @@ var d = /** @class */ (function (_super) {
         remult3_1.Fields.integer(),
         tslib_1.__metadata("design:type", Number)
     ], d.prototype, "b", void 0);
-    tslib_1.__decorate([
-        server_action_1.BackendMethod({ allowed: true }),
-        tslib_1.__metadata("design:type", Function),
-        tslib_1.__metadata("design:paramtypes", []),
-        tslib_1.__metadata("design:returntype", Promise)
-    ], d.prototype, "doIt", null);
     d = tslib_1.__decorate([
         remult3_1.Entity('d1', {
             allowApiCrud: true

package/src/tests/testHelper.spec.js

@@ -267,7 +267,7 @@ var MockRestDataProvider = /** @class */ (function () {
     MockRestDataProvider.prototype.getEntityDataProvider = function (metadata) {
         var _this = this;
         var dataApi = new data_api_1.DataApi(this.remult.repo(metadata.entityType), this.remult);
-        return new rest_data_provider_1.RestEntityDataProvider("", {
+        return new rest_data_provider_1.RestEntityDataProvider("", new context_1.HttpProviderBridgeToRestDataProviderHttpProvider({
             delete: function (url) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                 var urlSplit, r, result;
                 return tslib_1.__generator(this, function (_a) {
@@ -359,7 +359,7 @@ var MockRestDataProvider = /** @class */ (function () {
                     }
                 });
             }); }
-        }, metadata);
+        }), metadata);
     };
     MockRestDataProvider.prototype.transaction = function (action) {
         throw new Error('Method not implemented.');

package/src/tests/testModel/models.d.ts

@@ -5,7 +5,6 @@ export declare class Status {
     static closed: Status;
     static hold: Status;
     constructor(id: number, name: string);
-    toString(): string;
 }
 export declare class TestStatus {
     id?: string;

package/src/tests/testModel/models.js

@@ -9,9 +9,6 @@ var Status = /** @class */ (function () {
         this.name = name;
     }
     Status_1 = Status;
-    Status.prototype.toString = function () {
-        return this.name;
-    };
     var Status_1;
     Status.open = new Status_1(0, "open");
     Status.closed = new Status_1(1, "closed");