remult 0.22.3 → 0.22.5

package/esm/postgres/schema-builder.js

@@ -116,8 +116,8 @@ export class PostgresSchemaBuilder {
         try {
             let cmd = this.pool.createCommand();
             const colName = e.$dbNameOf(c(entity));
-            if ((await cmd.execute(`select 1   
-        FROM information_schema.columns 
+            if ((await cmd.execute(`select 1   
+        FROM information_schema.columns 
         WHERE table_name=${cmd.addParameterAndReturnSqlToken(e.$entityName.toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken(colName.toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
                 let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
                 if (PostgresSchemaBuilder.logToConsole)
@@ -133,8 +133,8 @@ export class PostgresSchemaBuilder {
         try {
             let cmd = this.pool.createCommand();
             let e = await dbNamesOf(entity);
-            let cols = (await cmd.execute(`select column_name   
-        FROM information_schema.columns 
+            let cols = (await cmd.execute(`select column_name   
+        FROM information_schema.columns 
         WHERE table_name=${cmd.addParameterAndReturnSqlToken(e.$entityName.toLocaleLowerCase())} ` + this.additionalWhere)).rows.map((x) => x.column_name.toLocaleLowerCase());
             for (const col of entity.fields) {
                 if (!isDbReadonly(col, e)) {

package/esm/src/context.d.ts

@@ -8,11 +8,15 @@ export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;
     static disable(): void;
-    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
+    constructor(remultObjectStorage: myAsyncLocalStorage<Remult>);
     run(remult: Remult, callback: VoidFunction): void;
     getRemult(): Remult;
     static instance: RemultAsyncLocalStorage;
 }
+declare type myAsyncLocalStorage<T> = {
+    run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
+    getStore(): T;
+};
 export declare function isBackend(): boolean;
 export declare class Remult {
     /**Return's a `Repository` of the specific entity type
@@ -127,3 +131,4 @@ export interface itemChange {
     deleted: boolean;
 }
 export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;
+export {};

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

@@ -124,7 +124,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     private _columns;
     get fields(): FieldsRef<T>;
     private _saving;
-    save(): Promise<T>;
+    save(onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject?: string[]): Promise<T>;
     private getIdFilter;
     delete(): Promise<void>;
     loadDataFrom(data: any, loadItems?: FieldMetadata[]): Promise<void>;

package/esm/src/remult3/RepositoryImplementation.js

@@ -190,8 +190,28 @@ export class RepositoryImplementation {
         }
     }
     async update(id, entity) {
+        {
+            let ref = getEntityRef(entity, false);
+            if (ref)
+                return (await ref.save());
+        }
         let ref = this.getRefForExistingRow(entity, id);
-        return (await ref.save());
+        if (this.dataProvider.isProxy) {
+            return await ref.save(Object.keys(entity));
+        }
+        else {
+            const r = await this.findId(ref.id, { useCache: false });
+            if (!r)
+                throw new Error('Not Found');
+            for (const key in entity) {
+                if (Object.prototype.hasOwnProperty.call(entity, key)) {
+                    let f = ref.fields[key];
+                    if (f)
+                        r[key] = f.value;
+                }
+            }
+            return await getEntityRef(r).save();
+        }
     }
     getRefForExistingRow(entity, id) {
         let ref = getEntityRef(entity, false);
@@ -909,7 +929,7 @@ export class rowHelperImplementation extends rowHelperBase {
         }
         return this._columns;
     }
-    async save() {
+    async save(onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject) {
         try {
             if (this._saving)
                 throw new Error('cannot save while entity is already saving');
@@ -917,7 +937,8 @@ export class rowHelperImplementation extends rowHelperBase {
             if (this.wasDeleted())
                 throw new Error('cannot save a deleted row');
             this.isLoading = true;
-            await this.__validateEntity();
+            if (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject === undefined) // no need
+                await this.__validateEntity();
             let doNotSave = false;
             for (const col of this.fields) {
                 if (col.metadata.options.saving)
@@ -930,7 +951,9 @@ export class rowHelperImplementation extends rowHelperBase {
             let d = this.copyDataToObject();
             let ignoreKeys = [];
             for (const field of this.metadata.fields) {
-                if (field.dbReadOnly) {
+                if (field.dbReadOnly ||
+                    (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject !== undefined &&
+                        !onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject.includes(field.key))) {
                     d[field.key] = undefined;
                     ignoreKeys.push(field.key);
                     let f = this.fields.find(field);

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

@@ -1117,3 +1117,60 @@ testAll('test relation to string id', async ({ createEntity }) => {
     expect(await taskRepo.count({ category: cat[1] })).toBe(1);
     expect(await taskRepo.count({ category: { $id: cat[0].id } })).toBe(2);
 }, false, { exclude: [TestDbs.mongo, TestDbs.mongoNoTrans] });
+testAll("test update doesn't override other values", async ({ createEntity, remult }) => {
+    const catRepo = await createEntity(Categories);
+    const cat = await catRepo.insert({ id: 1, categoryName: 'cat' });
+    const task = class {
+        constructor() {
+            this.id = 0;
+            this.title = '';
+            this.completed = false;
+        }
+    };
+    describeClass(task, Entity('tasks', { allowApiCrud: true }), {
+        id: Fields.integer(),
+        title: Fields.string(),
+        cat: Field(() => Categories),
+        completed: Fields.boolean(),
+    });
+    const taskRepo = await createEntity(task);
+    await taskRepo.insert({ id: 1, cat, title: 'noam' });
+    {
+        const aTask = await taskRepo.findFirst({}, { useCache: false });
+        expect(aTask.title).toBe('noam');
+        expect(aTask.cat.categoryName).toBe('cat');
+        expect(aTask.completed).toBe(false);
+    }
+    await taskRepo.update(1, { completed: true });
+    {
+        const aTask = await taskRepo.findFirst({}, { useCache: false });
+        expect(aTask.id).toBe(1);
+        expect(aTask.title).toBe('noam');
+        expect(aTask.cat.categoryName).toBe('cat');
+        expect(aTask.completed).toBe(true);
+    }
+}, false);
+testAll("test update doesn't validate non included fields", async ({ createEntity, remult }) => {
+    const catRepo = await createEntity(Categories);
+    const cat = await catRepo.insert({ id: 1, categoryName: 'cat' });
+    const task = class {
+        constructor() {
+            this.id = 0;
+            this.title = '';
+            this.completed = false;
+        }
+    };
+    describeClass(task, Entity('tasks', { allowApiCrud: true }), {
+        id: Fields.integer(),
+        title: Fields.string({ validate: Validators.required }),
+        cat: Field(() => Categories),
+        completed: Fields.boolean(),
+    });
+    const taskRepo = await createEntity(task);
+    await taskRepo.insert({ id: 1, cat, title: 'noam' });
+    await taskRepo.update(1, { completed: true });
+    {
+        const aTask = await taskRepo.findId(1, { useCache: false });
+        expect(aTask.completed).toBe(true);
+    }
+}, false);

package/esm/test-servers/shared/Task.d.ts

@@ -0,0 +1,9 @@
+import { Remult } from '../../core/src/context';
+export declare class Task {
+    id: string;
+    title: string;
+    completed: boolean;
+    static testForbidden(): void;
+    static testStaticRemult(): Promise<number>;
+    static testInjectedRemult(remult?: Remult): Promise<number>;
+}

package/esm/test-servers/shared/Task.js

@@ -0,0 +1,32 @@
+import { Entity, Fields } from '../../core/src/remult3';
+import { Validators } from '../../core/src/validators';
+import { BackendMethod } from '../../core/src/server-action';
+import { remult } from '../../core/src/remult-proxy';
+import { isBackend } from '../../core/src/context';
+@Entity("tasks", {
+    allowApiCrud: true
+})
+export class Task {
+    @Fields.uuid()
+    id;
+    @Fields.string({
+        validate: (r, c) => {
+            if (isBackend())
+                Validators.required(r, c);
+        }
+    })
+    title = '';
+    @Fields.boolean()
+    completed = false;
+    @BackendMethod({ allowed: false })
+    static testForbidden() {
+    }
+    @BackendMethod({ allowed: true })
+    static async testStaticRemult() {
+        return await remult.repo(Task).count();
+    }
+    @BackendMethod({ allowed: true })
+    static async testInjectedRemult(remult) {
+        return await remult.repo(Task).count();
+    }
+}

package/esm/test.d.ts

@@ -0,0 +1,5 @@
+export type ClassType<T> = {
+    new (...args: any[]): T;
+};
+export declare function Field1<valueType>(valueType: () => ClassType<valueType>): (target: any, context: ClassFieldDecoratorContext<any, valueType | undefined> | string) => void;
+export declare function createdAt(): (target: any, context: string | ClassFieldDecoratorContext<any, Date>) => void;

package/esm/test.js

@@ -0,0 +1,6 @@
+export function Field1(valueType) {
+    return (target, context) => { };
+}
+export function createdAt() {
+    return Field1(() => Date);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.22.3",
+    "version": "0.22.5",
     "description": "A CRUD framework for full-stack TypeScript",
     "types": "index.d.ts",
     "module": "esm/index.js",

package/src/context.d.ts

@@ -8,11 +8,15 @@ export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;
     static disable(): void;
-    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
+    constructor(remultObjectStorage: myAsyncLocalStorage<Remult>);
     run(remult: Remult, callback: VoidFunction): void;
     getRemult(): Remult;
     static instance: RemultAsyncLocalStorage;
 }
+declare type myAsyncLocalStorage<T> = {
+    run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
+    getStore(): T;
+};
 export declare function isBackend(): boolean;
 export declare class Remult {
     /**Return's a `Repository` of the specific entity type
@@ -127,3 +131,4 @@ export interface itemChange {
     deleted: boolean;
 }
 export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;
+export {};

package/src/remult3/RepositoryImplementation.d.ts

@@ -124,7 +124,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     private _columns;
     get fields(): FieldsRef<T>;
     private _saving;
-    save(): Promise<T>;
+    save(onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject?: string[]): Promise<T>;
     private getIdFilter;
     delete(): Promise<void>;
     loadDataFrom(data: any, loadItems?: FieldMetadata[]): Promise<void>;

package/src/remult3/RepositoryImplementation.js

@@ -324,13 +324,33 @@ var RepositoryImplementation = /** @class */ (function () {
     };
     RepositoryImplementation.prototype.update = function (id, entity) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var ref;
+            var ref_1, ref, r, key, f;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        ref = this.getRefForExistingRow(entity, id);
-                        return [4 /*yield*/, ref.save()];
+                        ref_1 = getEntityRef(entity, false);
+                        if (!ref_1) return [3 /*break*/, 2];
+                        return [4 /*yield*/, ref_1.save()];
                     case 1: return [2 /*return*/, (_a.sent())];
+                    case 2:
+                        ref = this.getRefForExistingRow(entity, id);
+                        if (!this.dataProvider.isProxy) return [3 /*break*/, 4];
+                        return [4 /*yield*/, ref.save(Object.keys(entity))];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4: return [4 /*yield*/, this.findId(ref.id, { useCache: false })];
+                    case 5:
+                        r = _a.sent();
+                        if (!r)
+                            throw new Error('Not Found');
+                        for (key in entity) {
+                            if (Object.prototype.hasOwnProperty.call(entity, key)) {
+                                f = ref.fields[key];
+                                if (f)
+                                    r[key] = f.value;
+                            }
+                        }
+                        return [4 /*yield*/, getEntityRef(r).save()];
+                    case 6: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -1525,7 +1545,7 @@ var rowHelperImplementation = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    rowHelperImplementation.prototype.save = function () {
+    rowHelperImplementation.prototype.save = function (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject) {
         var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var doNotSave_1, _b, _c, col, e_25_1, d, ignoreKeys, _d, _e, field, f, updatedRow, isNew, changesOnly, wasChanged, key, element, _f, _g, listener, e_26_1, err_1;
@@ -1533,58 +1553,63 @@ var rowHelperImplementation = /** @class */ (function (_super) {
             return tslib_1.__generator(this, function (_l) {
                 switch (_l.label) {
                     case 0:
-                        _l.trys.push([0, , 34, 35]);
+                        _l.trys.push([0, , 35, 36]);
                         if (this._saving)
                             throw new Error('cannot save while entity is already saving');
                         this._saving = true;
                         if (this.wasDeleted())
                             throw new Error('cannot save a deleted row');
                         this.isLoading = true;
+                        if (!(onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject === undefined)) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.__validateEntity()];
                     case 1:
                         _l.sent();
-                        doNotSave_1 = false;
                         _l.label = 2;
                     case 2:
-                        _l.trys.push([2, 7, 8, 9]);
-                        _b = tslib_1.__values(this.fields), _c = _b.next();
+                        doNotSave_1 = false;
                         _l.label = 3;
                     case 3:
-                        if (!!_c.done) return [3 /*break*/, 6];
+                        _l.trys.push([3, 8, 9, 10]);
+                        _b = tslib_1.__values(this.fields), _c = _b.next();
+                        _l.label = 4;
+                    case 4:
+                        if (!!_c.done) return [3 /*break*/, 7];
                         col = _c.value;
-                        if (!col.metadata.options.saving) return [3 /*break*/, 5];
+                        if (!col.metadata.options.saving) return [3 /*break*/, 6];
                         return [4 /*yield*/, col.metadata.options.saving(this.instance, col)];
-                    case 4:
-                        _l.sent();
-                        _l.label = 5;
                     case 5:
+                        _l.sent();
+                        _l.label = 6;
+                    case 6:
                         _c = _b.next();
-                        return [3 /*break*/, 3];
-                    case 6: return [3 /*break*/, 9];
-                    case 7:
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
                         e_25_1 = _l.sent();
                         e_25 = { error: e_25_1 };
-                        return [3 /*break*/, 9];
-                    case 8:
+                        return [3 /*break*/, 10];
+                    case 9:
                         try {
                             if (_c && !_c.done && (_h = _b.return)) _h.call(_b);
                         }
                         finally { if (e_25) throw e_25.error; }
                         return [7 /*endfinally*/];
-                    case 9:
-                        if (!this.info.entityInfo.saving) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this.info.entityInfo.saving(this.instance, function () { return (doNotSave_1 = true); })];
                     case 10:
-                        _l.sent();
-                        _l.label = 11;
+                        if (!this.info.entityInfo.saving) return [3 /*break*/, 12];
+                        return [4 /*yield*/, this.info.entityInfo.saving(this.instance, function () { return (doNotSave_1 = true); })];
                     case 11:
+                        _l.sent();
+                        _l.label = 12;
+                    case 12:
                         this.__assertValidity();
                         d = this.copyDataToObject();
                         ignoreKeys = [];
                         try {
                             for (_d = tslib_1.__values(this.metadata.fields), _e = _d.next(); !_e.done; _e = _d.next()) {
                                 field = _e.value;
-                                if (field.dbReadOnly) {
+                                if (field.dbReadOnly ||
+                                    (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject !== undefined &&
+                                        !onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject.includes(field.key))) {
                                     d[field.key] = undefined;
                                     ignoreKeys.push(field.key);
                                     f = this.fields.find(field);
@@ -1603,16 +1628,16 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                             delete d.id;
                         updatedRow = void 0;
                         isNew = this.isNew();
-                        _l.label = 12;
-                    case 12:
-                        _l.trys.push([12, 31, , 33]);
+                        _l.label = 13;
+                    case 13:
+                        _l.trys.push([13, 32, , 34]);
                         (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportChanged();
-                        if (!this.isNew()) return [3 /*break*/, 14];
+                        if (!this.isNew()) return [3 /*break*/, 15];
                         return [4 /*yield*/, this.edp.insert(d)];
-                    case 13:
-                        updatedRow = _l.sent();
-                        return [3 /*break*/, 18];
                     case 14:
+                        updatedRow = _l.sent();
+                        return [3 /*break*/, 19];
+                    case 15:
                         changesOnly = {};
                         wasChanged = false;
                         for (key in d) {
@@ -1627,70 +1652,70 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                         }
                         if (!wasChanged)
                             return [2 /*return*/, this.instance];
-                        if (!doNotSave_1) return [3 /*break*/, 16];
+                        if (!doNotSave_1) return [3 /*break*/, 17];
                         return [4 /*yield*/, this.edp.find({ where: this.getIdFilter() })];
-                    case 15:
+                    case 16:
                         updatedRow = (_l.sent())[0];
-                        return [3 /*break*/, 18];
-                    case 16: return [4 /*yield*/, this.edp.update(this.id, changesOnly)];
-                    case 17:
+                        return [3 /*break*/, 19];
+                    case 17: return [4 /*yield*/, this.edp.update(this.id, changesOnly)];
+                    case 18:
                         updatedRow = _l.sent();
-                        _l.label = 18;
-                    case 18: return [4 /*yield*/, this.loadDataFrom(updatedRow)];
-                    case 19:
-                        _l.sent();
-                        if (!this.info.entityInfo.saved) return [3 /*break*/, 21];
-                        return [4 /*yield*/, this.info.entityInfo.saved(this.instance)];
+                        _l.label = 19;
+                    case 19: return [4 /*yield*/, this.loadDataFrom(updatedRow)];
                     case 20:
                         _l.sent();
-                        _l.label = 21;
+                        if (!this.info.entityInfo.saved) return [3 /*break*/, 22];
+                        return [4 /*yield*/, this.info.entityInfo.saved(this.instance)];
                     case 21:
-                        if (!this.repository.listeners) return [3 /*break*/, 29];
+                        _l.sent();
                         _l.label = 22;
                     case 22:
-                        _l.trys.push([22, 27, 28, 29]);
-                        _f = tslib_1.__values(this.repository.listeners.filter(function (x) { return x.saved; })), _g = _f.next();
+                        if (!this.repository.listeners) return [3 /*break*/, 30];
                         _l.label = 23;
                     case 23:
-                        if (!!_g.done) return [3 /*break*/, 26];
+                        _l.trys.push([23, 28, 29, 30]);
+                        _f = tslib_1.__values(this.repository.listeners.filter(function (x) { return x.saved; })), _g = _f.next();
+                        _l.label = 24;
+                    case 24:
+                        if (!!_g.done) return [3 /*break*/, 27];
                         listener = _g.value;
                         return [4 /*yield*/, listener.saved(this.instance, isNew)];
-                    case 24:
-                        _l.sent();
-                        _l.label = 25;
                     case 25:
+                        _l.sent();
+                        _l.label = 26;
+                    case 26:
                         _g = _f.next();
-                        return [3 /*break*/, 23];
-                    case 26: return [3 /*break*/, 29];
-                    case 27:
+                        return [3 /*break*/, 24];
+                    case 27: return [3 /*break*/, 30];
+                    case 28:
                         e_26_1 = _l.sent();
                         e_26 = { error: e_26_1 };
-                        return [3 /*break*/, 29];
-                    case 28:
+                        return [3 /*break*/, 30];
+                    case 29:
                         try {
                             if (_g && !_g.done && (_k = _f.return)) _k.call(_f);
                         }
                         finally { if (e_26) throw e_26.error; }
                         return [7 /*endfinally*/];
-                    case 29: return [4 /*yield*/, this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }])];
-                    case 30:
+                    case 30: return [4 /*yield*/, this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }])];
+                    case 31:
                         _l.sent();
                         this.saveOriginalData();
                         this._isNew = false;
                         return [2 /*return*/, this.instance];
-                    case 31:
+                    case 32:
                         err_1 = _l.sent();
                         return [4 /*yield*/, this.catchSaveErrors(err_1)];
-                    case 32:
+                    case 33:
                         _l.sent();
-                        return [3 /*break*/, 33];
-                    case 33: return [3 /*break*/, 35];
-                    case 34:
+                        return [3 /*break*/, 34];
+                    case 34: return [3 /*break*/, 36];
+                    case 35:
                         this.isLoading = false;
                         this._reportChangedToEntityAndFields();
                         this._saving = false;
                         return [7 /*endfinally*/];
-                    case 35: return [2 /*return*/];
+                    case 36: return [2 /*return*/];
                 }
             });
         });

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

@@ -2441,3 +2441,100 @@ db_tests_setup_1.testAll('test relation to string id', function (_a) {
         });
     });
 }, false, { exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans] });
+db_tests_setup_1.testAll("test update doesn't override other values", function (_a) {
+    var createEntity = _a.createEntity, remult = _a.remult;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var catRepo, cat, task, taskRepo, aTask, aTask;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    catRepo = _b.sent();
+                    return [4 /*yield*/, catRepo.insert({ id: 1, categoryName: 'cat' })];
+                case 2:
+                    cat = _b.sent();
+                    task = /** @class */ (function () {
+                        function class_14() {
+                            this.id = 0;
+                            this.title = '';
+                            this.completed = false;
+                        }
+                        return class_14;
+                    }());
+                    DecoratorReplacer_1.describeClass(task, remult3_1.Entity('tasks', { allowApiCrud: true }), {
+                        id: remult3_1.Fields.integer(),
+                        title: remult3_1.Fields.string(),
+                        cat: remult3_1.Field(function () { return remult_3_entities_1.Categories; }),
+                        completed: remult3_1.Fields.boolean(),
+                    });
+                    return [4 /*yield*/, createEntity(task)];
+                case 3:
+                    taskRepo = _b.sent();
+                    return [4 /*yield*/, taskRepo.insert({ id: 1, cat: cat, title: 'noam' })];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, taskRepo.findFirst({}, { useCache: false })];
+                case 5:
+                    aTask = _b.sent();
+                    expect(aTask.title).toBe('noam');
+                    expect(aTask.cat.categoryName).toBe('cat');
+                    expect(aTask.completed).toBe(false);
+                    return [4 /*yield*/, taskRepo.update(1, { completed: true })];
+                case 6:
+                    _b.sent();
+                    return [4 /*yield*/, taskRepo.findFirst({}, { useCache: false })];
+                case 7:
+                    aTask = _b.sent();
+                    expect(aTask.id).toBe(1);
+                    expect(aTask.title).toBe('noam');
+                    expect(aTask.cat.categoryName).toBe('cat');
+                    expect(aTask.completed).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("test update doesn't validate non included fields", function (_a) {
+    var createEntity = _a.createEntity, remult = _a.remult;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var catRepo, cat, task, taskRepo, aTask;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    catRepo = _b.sent();
+                    return [4 /*yield*/, catRepo.insert({ id: 1, categoryName: 'cat' })];
+                case 2:
+                    cat = _b.sent();
+                    task = /** @class */ (function () {
+                        function class_15() {
+                            this.id = 0;
+                            this.title = '';
+                            this.completed = false;
+                        }
+                        return class_15;
+                    }());
+                    DecoratorReplacer_1.describeClass(task, remult3_1.Entity('tasks', { allowApiCrud: true }), {
+                        id: remult3_1.Fields.integer(),
+                        title: remult3_1.Fields.string({ validate: validators_1.Validators.required }),
+                        cat: remult3_1.Field(function () { return remult_3_entities_1.Categories; }),
+                        completed: remult3_1.Fields.boolean(),
+                    });
+                    return [4 /*yield*/, createEntity(task)];
+                case 3:
+                    taskRepo = _b.sent();
+                    return [4 /*yield*/, taskRepo.insert({ id: 1, cat: cat, title: 'noam' })];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, taskRepo.update(1, { completed: true })];
+                case 5:
+                    _b.sent();
+                    return [4 /*yield*/, taskRepo.findId(1, { useCache: false })];
+                case 6:
+                    aTask = _b.sent();
+                    expect(aTask.completed).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);

package/esm/src/id-entity.d.ts

@@ -1,4 +0,0 @@
-import { EntityBase } from './remult3';
-export declare class IdEntity extends EntityBase {
-    id: string;
-}

package/esm/src/id-entity.js

@@ -1,8 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { EntityBase, Fields } from './remult3';
-export class IdEntity extends EntityBase {
-}
-__decorate([
-    Fields.uuid(),
-    __metadata("design:type", String)
-], IdEntity.prototype, "id", void 0);

package/postgres/postgresColumnSyntax.d.ts

@@ -1,2 +0,0 @@
-import { FieldMetadata } from '../src/column-interfaces';
-export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;