remult 0.16.0-exp.9 → 0.16.2-exp.1

package/esm/remult-express.js

@@ -18,6 +18,6 @@ export function remultExpress(options) {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
         registerRouter: x => server.registerRouter(x),
-        withRemultMiddleware: (...args) => server.withRemultMiddleware(...args)
+        withRemult: (...args) => server.withRemult(...args)
     });
 }

package/esm/remult-fastify.js

@@ -47,6 +47,7 @@ export function remultFastify(options) {
     return Object.assign(pluginFunction, {
         getRemult: x => api.getRemult(x),
         openApiDoc: x => api.openApiDoc(x),
-        handle: (req, res) => api.handle(req, res)
+        handle: (req, res) => api.handle(req, res),
+        withRemult: (req, res, next) => api.withRemult(req, res, next)
     });
 }

package/esm/server/expressBridge.d.ts

@@ -33,7 +33,7 @@ export interface RemultServer {
     }): any;
     registerRouter(r: GenericRouter): void;
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    withRemultMiddleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
+    withRemult(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;

package/esm/server/expressBridge.js

@@ -4,7 +4,6 @@ import { DataApi, serializeError } from '../src/data-api';
 import { allEntities, Remult } from '../src/context';
 import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-import { AsyncLocalStorage } from 'async_hooks';
 import { remult } from '../src/remult-proxy';
 ;
 export function createRemultServer(options) {
@@ -31,6 +30,25 @@ export function createRemultServer(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
+    if (!remultObjectStorage) {
+        dataProvider = dataProvider.then(async (dp) => {
+            try {
+                const asyncHooks = await import('async_hooks');
+                remultObjectStorage = new RemultAsyncLocalStorage(new asyncHooks.AsyncLocalStorage());
+            }
+            catch {
+                remultObjectStorage = new RemultAsyncLocalStorage(undefined);
+            }
+            remult.remultFactory = () => {
+                const r = remultObjectStorage.getRemult();
+                if (r)
+                    return r;
+                else
+                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+            };
+            return dp;
+        });
+    }
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
@@ -60,8 +78,24 @@ export function createRemultServer(options) {
     return bridge;
 }
 ;
-const remultObjectStorage = new AsyncLocalStorage();
-let remultObjectStorageWasSetup = false;
+class RemultAsyncLocalStorage {
+    constructor(remultObjectStorage) {
+        this.remultObjectStorage = remultObjectStorage;
+    }
+    run(remult, callback) {
+        if (this.remultObjectStorage)
+            this.remultObjectStorage.run(remult, callback);
+        else
+            callback();
+    }
+    getRemult() {
+        if (!this.remultObjectStorage) {
+            throw "can't use static remult in this environment, `async_hooks` were not found";
+        }
+        return this.remultObjectStorage.getStore();
+    }
+}
+let remultObjectStorage;
 class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
@@ -71,18 +105,8 @@ class RemultServerImplementation {
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
-        if (!remultObjectStorageWasSetup) {
-            remultObjectStorageWasSetup = true;
-            remult.remultFactory = () => {
-                const r = remultObjectStorage.getStore();
-                if (r)
-                    return r;
-                else
-                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-            };
-        }
     }
-    withRemultMiddleware(req, res, next) {
+    withRemult(req, res, next) {
         this.process(async () => { next(); })(req, res);
     }
     handle(req, gRes) {

package/esm/src/backend-tests/test-http-server.backend-spec.js

@@ -1,7 +1,6 @@
 import { __decorate, __metadata } from "tslib";
 import axios from 'axios';
 import { remultFresh } from '../../remult-fresh';
-import { Remult } from '../context';
 import { InMemoryDataProvider } from '../data-providers/in-memory-database';
 import { remult } from '../remult-proxy';
 import { Entity, Fields } from '../remult3';
@@ -12,10 +11,10 @@ let path = remult.apiClient.url + '/tasks';
 const environments = [
 // ["next", 3000],
 // ["nest", 3001],
-// ["koa", 3002],
-// ["fastify", 3003],
-// ["express", 3004],
-// ["generic server", 3005],
+//  ["koa", 3002],
+//  ["fastify", 3003],
+//  ["express", 3004],
+//  ["generic server", 3005],
 // ["optine", 3006],
 // ["fresh", 8000]
 ];
@@ -160,7 +159,6 @@ Task = __decorate([
 ], Task);
 export { Task };
 async function create3Tasks() {
-    const remult = new Remult(axios);
     remult.apiClient.httpClient = axios;
     const taskRepo = remult.repo(Task);
     for (const task of await taskRepo.find()) {

package/esm/src/context.d.ts

@@ -94,8 +94,8 @@ export declare function buildRestDataProvider(provider: ExternalHttpProvider | t
 export declare function setControllerSettings(target: any, options: ControllerOptions): void;
 export interface UserInfo {
     id: string;
-    name: string;
-    roles: 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);

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -30,6 +30,9 @@ export declare class RestDataProviderHttpProviderUsingFetch implements RestDataP
     put(url: string, data: any): Promise<any>;
     delete(url: string): Promise<any>;
     post(url: string, data: any): Promise<any>;
-    myFetch(url: string, init?: RequestInit): Promise<any>;
+    myFetch(url: string, options?: {
+        method?: string;
+        body?: string;
+    }): Promise<any>;
 }
 export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;

package/esm/src/data-providers/rest-data-provider.js

@@ -122,7 +122,7 @@ export class RestDataProviderHttpProviderUsingFetch {
         });
     }
     delete(url) {
-        return this.myFetch(url, { method: 'delete', credentials: 'include' });
+        return this.myFetch(url, { method: 'delete' });
     }
     async post(url, data) {
         return await retry(() => this.myFetch(url, {
@@ -130,15 +130,22 @@ export class RestDataProviderHttpProviderUsingFetch {
             body: JSON.stringify(data)
         }));
     }
-    myFetch(url, init) {
-        if (!init)
-            init = {};
-        if (!init.headers)
-            init.headers = new Headers();
-        var h = init.headers;
-        h.append('Content-type', "application/json");
-        init.credentials = 'include';
-        return (this.fetch || fetch)(url, init).then(response => {
+    myFetch(url, options) {
+        const headers = {
+            "Content-type": "application/json"
+        };
+        if (typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof (window.document.cookie !== 'undefined'))
+            for (const cookie of window.document.cookie.split(';')) {
+                if (cookie.trim().startsWith('XSRF-TOKEN=')) {
+                    headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
+                }
+            }
+        return (this.fetch || fetch)(url, {
+            credentials: 'include',
+            method: options?.method,
+            body: options?.body,
+            headers
+        }).then(response => {
             return onSuccess(response);
         }).catch(async (error) => {
             let r = await error;

package/esm/src/entity.d.ts

@@ -42,7 +42,7 @@ export interface EntityOptions<entityType = any> {
      */
     defaultOrderBy?: EntityOrderBy<entityType>;
     /** An event that will be fired before the Entity will be saved to the database.
-    * 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.
+    * If the `error` property of the entity's ref or any of its 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", {

package/esm/src/remult3/RepositoryImplementation.js

@@ -693,7 +693,7 @@ export class rowHelperImplementation extends rowHelperBase {
         this.metadata = info;
         if (_isNew) {
             for (const col of info.columnsInfo) {
-                if (col.defaultValue) {
+                if (col.defaultValue && instance[col.key] === undefined) {
                     if (typeof col.defaultValue === "function") {
                         instance[col.key] = col.defaultValue(instance);
                     }

package/esm/src/remult3/remult3.d.ts

@@ -157,7 +157,7 @@ export interface Repository<entityType> {
     */
     insert(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     insert(item: Partial<OmitEB<entityType>>): Promise<entityType>;
-    /** Updates an item, based on it's `id`
+    /** Updates an item, based on its `id`
      * @example
      * taskRepo.update(task.id,{...task,completed:true})
     */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.16.0-exp.9",
+    "version": "0.16.2-exp.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -23,50 +23,98 @@
     "exports": {
         ".": {
             "require": "./index.js",
+            "node": {
+                "require": "./index.js",
+                "import": "./index.js"
+            },
             "import": "./esm/index.js"
         },
         "./remult-express": {
             "require": "./remult-express.js",
+            "node": {
+                "require": "./remult-express.js",
+                "import": "./remult-express.js"
+            },
             "import": "./esm/remult-express.js"
         },
         "./server": {
             "require": "./server/index.js",
+            "node": {
+                "require": "./server/index.js",
+                "import": "./server/index.js"
+            },
             "import": "./esm/server/index.js"
         },
         "./remult-fastify": {
             "require": "./remult-fastify.js",
+            "node": {
+                "require": "./remult-fastify.js",
+                "import": "./remult-fastify.js"
+            },
             "import": "./esm/remult-fastify.js"
         },
         "./remult-fresh": {
             "require": "./remult-fresh.js",
+            "node": {
+                "require": "./remult-fresh.js",
+                "import": "./remult-fresh.js"
+            },
             "import": "./esm/remult-fresh.js"
         },
         "./postgres": {
             "require": "./postgres/index.js",
+            "node": {
+                "require": "./postgres/index.js",
+                "import": "./postgres/index.js"
+            },
             "import": "./esm/postgres/index.js"
         },
         "./postgres/schema-builder": {
             "require": "./postgres/schema-builder.js",
+            "node": {
+                "require": "./postgres/schema-builder.js",
+                "import": "./postgres/schema-builder.js"
+            },
             "import": "./esm/postgres/schema-builder.js"
         },
         "./remult-knex": {
             "require": "./remult-knex/index.js",
+            "node": {
+                "require": "./remult-knex/index.js",
+                "import": "./remult-knex/index.js"
+            },
             "import": "./esm/remult-knex/index.js"
         },
         "./remult-mongo": {
             "require": "./remult-mongo.js",
+            "node": {
+                "require": "./remult-mongo.js",
+                "import": "./remult-mongo.js"
+            },
             "import": "./esm/remult-mongo.js"
         },
         "./graphql": {
             "require": "./graphql.js",
+            "node": {
+                "require": "./graphql.js",
+                "import": "./graphql.js"
+            },
             "import": "./esm/graphql.js"
         },
         "./src/remult3": {
             "require": "./src/remult3/index.js",
+            "node": {
+                "require": "./src/remult3/index.js",
+                "import": "./src/remult3/index.js"
+            },
             "import": "./esm/src/remult3/index.js"
         },
         "./src/server-action": {
             "require": "./src/server-action.js",
+            "node": {
+                "require": "./src/server-action.js",
+                "import": "./src/server-action.js"
+            },
             "import": "./esm/src/server-action.js"
         }
     }

package/remult-express.js

@@ -22,12 +22,12 @@ function remultExpress(options) {
         getRemult: function (req) { return server.getRemult(req); },
         openApiDoc: function (options) { return server.openApiDoc(options); },
         registerRouter: function (x) { return server.registerRouter(x); },
-        withRemultMiddleware: function () {
+        withRemult: function () {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            return server.withRemultMiddleware.apply(server, tslib_1.__spread(args));
+            return server.withRemult.apply(server, tslib_1.__spread(args));
         }
     });
 }

package/remult-fastify.js

@@ -55,7 +55,8 @@ function remultFastify(options) {
     return Object.assign(pluginFunction, {
         getRemult: function (x) { return api.getRemult(x); },
         openApiDoc: function (x) { return api.openApiDoc(x); },
-        handle: function (req, res) { return api.handle(req, res); }
+        handle: function (req, res) { return api.handle(req, res); },
+        withRemult: function (req, res, next) { return api.withRemult(req, res, next); }
     });
 }
 exports.remultFastify = remultFastify;

package/server/expressBridge.d.ts

@@ -33,7 +33,7 @@ export interface RemultServer {
     }): any;
     registerRouter(r: GenericRouter): void;
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    withRemultMiddleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
+    withRemult(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;

package/server/expressBridge.js

@@ -7,7 +7,6 @@ var data_api_1 = require("../src/data-api");
 var context_1 = require("../src/context");
 var remult3_1 = require("../src/remult3");
 var id_entity_1 = require("../src/id-entity");
-var async_hooks_1 = require("async_hooks");
 var remult_proxy_1 = require("../src/remult-proxy");
 ;
 function createRemultServer(options) {
@@ -41,6 +40,35 @@ function createRemultServer(options) {
             }
         });
     }); });
+    if (!remultObjectStorage) {
+        dataProvider = dataProvider.then(function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var asyncHooks, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('async_hooks'); })];
+                    case 1:
+                        asyncHooks = _b.sent();
+                        remultObjectStorage = new RemultAsyncLocalStorage(new asyncHooks.AsyncLocalStorage());
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        remultObjectStorage = new RemultAsyncLocalStorage(undefined);
+                        return [3 /*break*/, 3];
+                    case 3:
+                        remult_proxy_1.remult.remultFactory = function () {
+                            var r = remultObjectStorage.getRemult();
+                            if (r)
+                                return r;
+                            else
+                                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+                        };
+                        return [2 /*return*/, dp];
+                }
+            });
+        }); });
+    }
     if (options.initApi) {
         dataProvider = dataProvider.then(function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var remult;
@@ -87,8 +115,25 @@ function createRemultServer(options) {
 }
 exports.createRemultServer = createRemultServer;
 ;
-var remultObjectStorage = new async_hooks_1.AsyncLocalStorage();
-var remultObjectStorageWasSetup = false;
+var RemultAsyncLocalStorage = /** @class */ (function () {
+    function RemultAsyncLocalStorage(remultObjectStorage) {
+        this.remultObjectStorage = remultObjectStorage;
+    }
+    RemultAsyncLocalStorage.prototype.run = function (remult, callback) {
+        if (this.remultObjectStorage)
+            this.remultObjectStorage.run(remult, callback);
+        else
+            callback();
+    };
+    RemultAsyncLocalStorage.prototype.getRemult = function () {
+        if (!this.remultObjectStorage) {
+            throw "can't use static remult in this environment, `async_hooks` were not found";
+        }
+        return this.remultObjectStorage.getStore();
+    };
+    return RemultAsyncLocalStorage;
+}());
+var remultObjectStorage;
 var RemultServerImplementation = /** @class */ (function () {
     function RemultServerImplementation(queue, options, dataProvider) {
         this.queue = queue;
@@ -98,18 +143,8 @@ var RemultServerImplementation = /** @class */ (function () {
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
-        if (!remultObjectStorageWasSetup) {
-            remultObjectStorageWasSetup = true;
-            remult_proxy_1.remult.remultFactory = function () {
-                var r = remultObjectStorage.getStore();
-                if (r)
-                    return r;
-                else
-                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-            };
-        }
     }
-    RemultServerImplementation.prototype.withRemultMiddleware = function (req, res, next) {
+    RemultServerImplementation.prototype.withRemult = function (req, res, next) {
         var _this = this;
         this.process(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
             next();

package/src/backend-tests/test-http-server.backend-spec.js

@@ -4,7 +4,6 @@ exports.Task = void 0;
 var tslib_1 = require("tslib");
 var axios_1 = require("axios");
 var remult_fresh_1 = require("../../remult-fresh");
-var context_1 = require("../context");
 var in_memory_database_1 = require("../data-providers/in-memory-database");
 var remult_proxy_1 = require("../remult-proxy");
 var remult3_1 = require("../remult3");
@@ -15,10 +14,10 @@ var path = remult_proxy_1.remult.apiClient.url + '/tasks';
 var environments = [
 // ["next", 3000],
 // ["nest", 3001],
-// ["koa", 3002],
-// ["fastify", 3003],
-// ["express", 3004],
-// ["generic server", 3005],
+//  ["koa", 3002],
+//  ["fastify", 3003],
+//  ["express", 3004],
+//  ["generic server", 3005],
 // ["optine", 3006],
 // ["fresh", 8000]
 ];
@@ -289,14 +288,13 @@ var Task = /** @class */ (function () {
 exports.Task = Task;
 function create3Tasks() {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var remult, taskRepo, _a, _b, task, e_2_1, _c, _d;
+        var taskRepo, _a, _b, task, e_2_1, _c, _d;
         var e_2, _e;
         return tslib_1.__generator(this, function (_f) {
             switch (_f.label) {
                 case 0:
-                    remult = new context_1.Remult(axios_1.default);
-                    remult.apiClient.httpClient = axios_1.default;
-                    taskRepo = remult.repo(Task);
+                    remult_proxy_1.remult.apiClient.httpClient = axios_1.default;
+                    taskRepo = remult_proxy_1.remult.repo(Task);
                     _f.label = 1;
                 case 1:
                     _f.trys.push([1, 7, 8, 9]);

package/src/context.d.ts

@@ -94,8 +94,8 @@ export declare function buildRestDataProvider(provider: ExternalHttpProvider | t
 export declare function setControllerSettings(target: any, options: ControllerOptions): void;
 export interface UserInfo {
     id: string;
-    name: string;
-    roles: 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);

package/src/data-providers/rest-data-provider.d.ts

@@ -30,6 +30,9 @@ export declare class RestDataProviderHttpProviderUsingFetch implements RestDataP
     put(url: string, data: any): Promise<any>;
     delete(url: string): Promise<any>;
     post(url: string, data: any): Promise<any>;
-    myFetch(url: string, init?: RequestInit): Promise<any>;
+    myFetch(url: string, options?: {
+        method?: string;
+        body?: string;
+    }): Promise<any>;
 }
 export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;

package/src/data-providers/rest-data-provider.js

@@ -189,7 +189,7 @@ var RestDataProviderHttpProviderUsingFetch = /** @class */ (function () {
         });
     };
     RestDataProviderHttpProviderUsingFetch.prototype.delete = function (url) {
-        return this.myFetch(url, { method: 'delete', credentials: 'include' });
+        return this.myFetch(url, { method: 'delete' });
     };
     RestDataProviderHttpProviderUsingFetch.prototype.post = function (url, data) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
@@ -205,16 +205,34 @@ var RestDataProviderHttpProviderUsingFetch = /** @class */ (function () {
             });
         });
     };
-    RestDataProviderHttpProviderUsingFetch.prototype.myFetch = function (url, init) {
+    RestDataProviderHttpProviderUsingFetch.prototype.myFetch = function (url, options) {
+        var e_4, _a;
         var _this = this;
-        if (!init)
-            init = {};
-        if (!init.headers)
-            init.headers = new Headers();
-        var h = init.headers;
-        h.append('Content-type', "application/json");
-        init.credentials = 'include';
-        return (this.fetch || fetch)(url, init).then(function (response) {
+        var headers = {
+            "Content-type": "application/json"
+        };
+        if (typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof (window.document.cookie !== 'undefined'))
+            try {
+                for (var _b = tslib_1.__values(window.document.cookie.split(';')), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var cookie = _c.value;
+                    if (cookie.trim().startsWith('XSRF-TOKEN=')) {
+                        headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        return (this.fetch || fetch)(url, {
+            credentials: 'include',
+            method: options === null || options === void 0 ? void 0 : options.method,
+            body: options === null || options === void 0 ? void 0 : options.body,
+            headers: headers
+        }).then(function (response) {
             return onSuccess(response);
         }).catch(function (error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var r;

package/src/entity.d.ts

@@ -42,7 +42,7 @@ export interface EntityOptions<entityType = any> {
      */
     defaultOrderBy?: EntityOrderBy<entityType>;
     /** An event that will be fired before the Entity will be saved to the database.
-    * 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.
+    * If the `error` property of the entity's ref or any of its 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", {

package/src/remult3/RepositoryImplementation.js

@@ -1161,7 +1161,7 @@ var rowHelperImplementation = /** @class */ (function (_super) {
             try {
                 for (var _b = tslib_1.__values(info.columnsInfo), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var col = _c.value;
-                    if (col.defaultValue) {
+                    if (col.defaultValue && instance[col.key] === undefined) {
                         if (typeof col.defaultValue === "function") {
                             instance[col.key] = col.defaultValue(instance);
                         }

package/src/remult3/remult3.d.ts

@@ -157,7 +157,7 @@ export interface Repository<entityType> {
     */
     insert(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     insert(item: Partial<OmitEB<entityType>>): Promise<entityType>;
-    /** Updates an item, based on it's `id`
+    /** Updates an item, based on its `id`
      * @example
      * taskRepo.update(task.id,{...task,completed:true})
     */