remult 0.13.19 → 0.13.20

package/src/remult3/remult3.d.ts

@@ -103,43 +103,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;
     } ? number : entityType extends {
         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;
     } ? number : entityType extends {
         id: string;
     } ? string : (string | number)), item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    /** Deletes an Item*/
     delete(id: (entityType extends {
         id: number;
     } ? number : entityType extends {
         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,24 +184,25 @@ 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);
@@ -201,41 +239,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.github.io/guide/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/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.');