remult 0.22.8 → 0.22.9

package/src/remult3/Fields.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTarget = exports.Field = exports.Relations = exports.Fields = void 0;
+var tslib_1 = require("tslib");
+var cuid2_1 = require("@paralleldrive/cuid2");
+var uuid_1 = require("uuid");
+var valueConverters_1 = require("../valueConverters");
+var RepositoryImplementation_1 = require("./RepositoryImplementation");
+var relationInfoMember_1 = require("./relationInfoMember");
+var Fields = /** @class */ (function () {
+    function Fields() {
+    }
+    /**
+     * Stored as a JSON.stringify - to store as json use Fields.json
+     */
+    Fields.object = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([undefined], tslib_1.__read(options), false));
+    };
+    Fields.json = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([undefined,
+            {
+                valueConverter: {
+                    fieldTypeInDb: 'json',
+                },
+            }], tslib_1.__read(options), false));
+    };
+    Fields.dateOnly = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Date; },
+            {
+                valueConverter: valueConverters_1.ValueConverters.DateOnly,
+            }], tslib_1.__read(options), false));
+    };
+    Fields.date = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Date; }], tslib_1.__read(options), false));
+    };
+    Fields.integer = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; },
+            {
+                valueConverter: valueConverters_1.ValueConverters.Integer,
+            }], tslib_1.__read(options), false));
+    };
+    Fields.autoIncrement = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; },
+            {
+                allowApiUpdate: false,
+                dbReadOnly: true,
+                valueConverter: tslib_1.__assign(tslib_1.__assign({}, valueConverters_1.ValueConverters.Integer), { fieldTypeInDb: 'autoincrement' }),
+            }], tslib_1.__read(options), false));
+    };
+    Fields.number = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; }], tslib_1.__read(options), false));
+    };
+    Fields.createdAt = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Date; },
+            {
+                allowApiUpdate: false,
+                saving: function (_, _a, ref) {
+                    var isNew = _a.isNew;
+                    if (isNew)
+                        ref.value = new Date();
+                },
+            }], tslib_1.__read(options), false));
+    };
+    Fields.updatedAt = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Date; },
+            {
+                allowApiUpdate: false,
+                saving: function (_, _1, ref) {
+                    ref.value = new Date();
+                },
+            }], tslib_1.__read(options), false));
+    };
+    Fields.uuid = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return String; },
+            {
+                allowApiUpdate: false,
+                defaultValue: function () { return (0, uuid_1.v4)(); },
+                saving: function (_, _1, r) {
+                    if (!r.value)
+                        r.value = (0, uuid_1.v4)();
+                },
+            }], tslib_1.__read(options), false));
+    };
+    Fields.cuid = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return String; },
+            {
+                allowApiUpdate: false,
+                defaultValue: function () { return (0, cuid2_1.createId)(); },
+                saving: function (_, _1, r) {
+                    if (!r.value)
+                        r.value = (0, cuid2_1.createId)();
+                },
+            }], tslib_1.__read(options), false));
+    };
+    Fields.string = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return String; }], tslib_1.__read(options), false));
+    };
+    Fields.boolean = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Boolean; }], tslib_1.__read(options), false));
+    };
+    return Fields;
+}());
+exports.Fields = Fields;
+var Relations = /** @class */ (function () {
+    function Relations() {
+    }
+    Relations.toOne = function (toEntityType, options) {
+        var _a, _b;
+        var op = (typeof options === 'string'
+            ? { field: options }
+            : !options
+                ? {}
+                : options);
+        if (!op.field && !op.fields && !op.findOptions)
+            return Field(toEntityType, tslib_1.__assign(tslib_1.__assign({}, op), (_a = {}, _a[relationInfoMember_1.relationInfoMember] = {
+                //field,
+                toType: toEntityType,
+                type: 'reference',
+            }, _a)));
+        return Field(function () { return undefined; }, tslib_1.__assign(tslib_1.__assign({}, op), (_b = { serverExpression: function () { return undefined; } }, _b[relationInfoMember_1.relationInfoMember] = {
+            //field,
+            toType: toEntityType,
+            type: 'toOne',
+        }, _b)));
+    };
+    Relations.toMany = function (toEntityType, options) {
+        var _a;
+        var op = (typeof options === 'string'
+            ? { field: options }
+            : options);
+        return Field(function () { return undefined; }, tslib_1.__assign(tslib_1.__assign({}, op), (_a = { serverExpression: function () { return undefined; } }, _a[relationInfoMember_1.relationInfoMember] = {
+            //field,
+            toType: toEntityType,
+            type: 'toMany',
+        }, _a)));
+    };
+    return Relations;
+}());
+exports.Relations = Relations;
+/**Decorates fields that should be used as fields.
+ * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
+ *
+ * FieldOptions can be set in two ways:
+ * @example
+ * // as an object
+ * @Fields.string({ includeInApi:false })
+ * title='';
+ * @example
+ * // as an arrow function that receives `remult` as a parameter
+ * @Fields.string((options,remult) => options.includeInApi = true)
+ * title='';
+ */
+function Field(valueType) {
+    // import ANT!!!! if you call this in another decorator, make sure to set It's return type correctly with the | undefined
+    var options = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        options[_i - 1] = arguments[_i];
+    }
+    return function (target, context, c) {
+        var key = typeof context === 'string' ? context : context.name.toString();
+        var factory = function (remult) {
+            var r = (0, RepositoryImplementation_1.buildOptions)(options, remult);
+            if (!r.valueType && valueType) {
+                r.valueType = valueType();
+            }
+            if (!r.key) {
+                r.key = key;
+            }
+            if (!r.dbName)
+                r.dbName = r.key;
+            var type = r.valueType;
+            if (!type) {
+                type = Reflect.getMetadata('design:type', target, key);
+                r.valueType = type;
+            }
+            if (!r.target)
+                r.target = target;
+            return r;
+        };
+        checkTarget(target);
+        var names = RepositoryImplementation_1.columnsOfType.get(target.constructor);
+        if (!names) {
+            names = [];
+            RepositoryImplementation_1.columnsOfType.set(target.constructor, names);
+        }
+        var set = names.find(function (x) { return x.key == key; });
+        if (!set)
+            names.push({
+                key: key,
+                settings: factory,
+            });
+        else {
+            var prev_1 = set.settings;
+            set.settings = function (c) {
+                var prevO = prev_1(c);
+                var curr = factory(c);
+                return Object.assign(prevO, curr);
+            };
+        }
+    };
+}
+exports.Field = Field;
+function checkTarget(target) {
+    if (!target)
+        throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
+}
+exports.checkTarget = checkTarget;

package/src/remult3/IdEntity.d.ts

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

package/src/remult3/IdEntity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdEntity = void 0;
+var tslib_1 = require("tslib");
+var Fields_1 = require("./Fields");
+var RepositoryImplementation_1 = require("./RepositoryImplementation");
+var IdEntity = /** @class */ (function (_super) {
+    tslib_1.__extends(IdEntity, _super);
+    function IdEntity() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    tslib_1.__decorate([
+        Fields_1.Fields.uuid(),
+        tslib_1.__metadata("design:type", String)
+    ], IdEntity.prototype, "id", void 0);
+    return IdEntity;
+}(RepositoryImplementation_1.EntityBase));
+exports.IdEntity = IdEntity;

package/src/remult3/RepositoryImplementation.d.ts

@@ -98,7 +98,7 @@ declare abstract class rowHelperBase<T> {
     __validateEntity(): Promise<void>;
     __performColumnAndEntityValidations(): Promise<void>;
     toApiJson(includeRelatedEntities?: boolean): any;
-    _updateEntityBasedOnApi(body: any): Promise<void>;
+    _updateEntityBasedOnApi(body: any, ignoreApiAllowed?: boolean): Promise<void>;
 }
 export declare class rowHelperImplementation<T> extends rowHelperBase<T> implements EntityRef<T> {
     private info;

package/src/remult3/RepositoryImplementation.js

@@ -1332,7 +1332,8 @@ var rowHelperBase = /** @class */ (function () {
         }
         return result;
     };
-    rowHelperBase.prototype._updateEntityBasedOnApi = function (body) {
+    rowHelperBase.prototype._updateEntityBasedOnApi = function (body, ignoreApiAllowed) {
+        if (ignoreApiAllowed === void 0) { ignoreApiAllowed = false; }
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var keys, _a, _b, col, lu;
             var e_22, _c;
@@ -1347,6 +1348,7 @@ var rowHelperBase = /** @class */ (function () {
                                     if (col.includeInApi === undefined ||
                                         this.remult.isAllowed(col.includeInApi)) {
                                         if (!this.remult ||
+                                            ignoreApiAllowed ||
                                             col.allowApiUpdate === undefined ||
                                             this.remult.isAllowedForInstance(this.instance, col.allowApiUpdate)) {
                                             lu = this.lookups.get(col.key);

package/src/remult3/columnInfo.d.ts

@@ -0,0 +1,6 @@
+import type { FieldOptions } from '../column-interfaces';
+import { Remult } from '../context';
+export interface columnInfo {
+    key: string;
+    settings: (remult: Remult) => FieldOptions;
+}

package/src/remult3/columnInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/remult3/relation-loader-types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassType } from '../../classType';
+import type { EntityMetadata, FindOptions } from './remult3';
+export interface RelationLoaderHelper<toEntity> {
+    metadata: EntityMetadata<toEntity>;
+    entityType: ClassType<toEntity>;
+    find(options: FindOptions<toEntity>): Promise<toEntity[]>;
+}

package/src/remult3/relation-loader-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/remult3/relation-loader.d.ts

@@ -0,0 +1,40 @@
+import type { RelationLoaderHelper } from './relation-loader-types';
+import type { FindOptions } from './remult3';
+export declare class RelationLoader {
+    entityLoaders: Map<any, EntityLoader>;
+    promises: any[];
+    load(rel: RelationLoaderHelper<any>, findOptions: FindOptions<any>): Promise<any[]>;
+    constructor();
+    resolveAll(): Promise<void>;
+}
+declare class EntityLoader {
+    private rel;
+    queries: Map<string, QueryVariation>;
+    find(findOptions: FindOptions<any>): Promise<any[]>;
+    constructor(rel: RelationLoaderHelper<any>);
+}
+declare class QueryVariation {
+    private rel;
+    find(findOptions: FindOptions<any>, where: any): Promise<any[]>;
+    constructor(rel: RelationLoaderHelper<any>);
+    resolve(): void;
+    pendingInStatements: Map<string, PendingInStatements>;
+    whereVariations: Map<string, {
+        result: Promise<any[]>;
+    }>;
+}
+declare class PendingInStatements {
+    private rel;
+    private key;
+    private options;
+    resolve(): void;
+    find(where: any): Promise<any[]>;
+    values: Map<any, {
+        value: any;
+        resolve: (value: any[]) => void;
+        reject: (error: any) => void;
+        result: Promise<any[]>;
+    }>;
+    constructor(rel: RelationLoaderHelper<any>, key: string, options: FindOptions<any>);
+}
+export {};

package/src/remult3/relation-loader.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationLoader = void 0;
+var tslib_1 = require("tslib");
+var rest_data_provider_1 = require("../data-providers/rest-data-provider");
+var getEntityRef_1 = require("./getEntityRef");
+var relationInfoMember_1 = require("./relationInfoMember");
+var RelationLoader = /** @class */ (function () {
+    function RelationLoader() {
+        this.entityLoaders = new Map();
+        this.promises = [];
+    }
+    RelationLoader.prototype.load = function (rel, findOptions) {
+        var e = this.entityLoaders.get(rel.entityType);
+        if (!e) {
+            this.entityLoaders.set(rel.entityType, (e = new EntityLoader(rel)));
+        }
+        var p = e.find(findOptions);
+        this.promises.push(p);
+        return p;
+    };
+    RelationLoader.prototype.resolveAll = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, entity, _c, _d, variation, x;
+            var e_1, _e, e_2, _f;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        try {
+                            for (_a = tslib_1.__values(this.entityLoaders.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                entity = _b.value;
+                                try {
+                                    for (_c = (e_2 = void 0, tslib_1.__values(entity.queries.values())), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                        variation = _d.value;
+                                        variation.resolve();
+                                    }
+                                }
+                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                finally {
+                                    try {
+                                        if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        if (this.promises.length === 0)
+                            return [2 /*return*/];
+                        x = this.promises;
+                        this.promises = [];
+                        return [4 /*yield*/, Promise.all(x)];
+                    case 1:
+                        _g.sent();
+                        return [4 /*yield*/, this.resolveAll()];
+                    case 2:
+                        _g.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return RelationLoader;
+}());
+exports.RelationLoader = RelationLoader;
+var EntityLoader = /** @class */ (function () {
+    function EntityLoader(rel) {
+        this.rel = rel;
+        this.queries = new Map();
+    }
+    EntityLoader.prototype.find = function (findOptions) {
+        var _a = (0, rest_data_provider_1.findOptionsToJson)(findOptions, this.rel.metadata), where = _a.where, options = tslib_1.__rest(_a, ["where"]);
+        var optionKeys = JSON.stringify(options);
+        var q = this.queries.get(optionKeys);
+        if (!q) {
+            this.queries.set(optionKeys, (q = new QueryVariation(this.rel)));
+        }
+        return q.find(findOptions, where);
+    };
+    return EntityLoader;
+}());
+var QueryVariation = /** @class */ (function () {
+    function QueryVariation(rel) {
+        this.rel = rel;
+        this.pendingInStatements = new Map();
+        this.whereVariations = new Map();
+    }
+    QueryVariation.prototype.find = function (findOptions, where) {
+        var whereKey = JSON.stringify(where);
+        var w = this.whereVariations.get(whereKey);
+        if (!w) {
+            var keys = Object.keys(where);
+            if (keys.length === 1 &&
+                typeof where[keys[0]] !== 'object' &&
+                !findOptions.limit // because merging calls in that case may bring non more rows than the limit
+            ) {
+                var inVariation = this.pendingInStatements.get(keys[0]);
+                if (!inVariation) {
+                    this.pendingInStatements.set(keys[0], (inVariation = new PendingInStatements(this.rel, keys[0], findOptions)));
+                }
+                this.whereVariations.set(whereKey, (w = {
+                    result: inVariation.find(where),
+                }));
+            }
+            else {
+                this.whereVariations.set(whereKey, (w = {
+                    result: this.rel.find(findOptions),
+                }));
+            }
+        }
+        return w.result;
+    };
+    QueryVariation.prototype.resolve = function () {
+        var e_3, _a;
+        var statements = tslib_1.__spreadArray([], tslib_1.__read(this.pendingInStatements.values()), false);
+        this.pendingInStatements.clear();
+        try {
+            for (var statements_1 = tslib_1.__values(statements), statements_1_1 = statements_1.next(); !statements_1_1.done; statements_1_1 = statements_1.next()) {
+                var statement = statements_1_1.value;
+                statement.resolve();
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (statements_1_1 && !statements_1_1.done && (_a = statements_1.return)) _a.call(statements_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    return QueryVariation;
+}());
+var PendingInStatements = /** @class */ (function () {
+    function PendingInStatements(rel, key, options) {
+        this.rel = rel;
+        this.key = key;
+        this.options = options;
+        this.values = new Map();
+    }
+    PendingInStatements.prototype.resolve = function () {
+        var _a;
+        var _this = this;
+        var values = tslib_1.__spreadArray([], tslib_1.__read(this.values.values()), false);
+        if (values.length == 1) {
+            this.rel.find(this.options).then(values[0].resolve, values[0].reject);
+            return;
+        }
+        var op = tslib_1.__assign({}, this.options);
+        op.where = (_a = {}, _a[this.key] = values.map(function (v) { return v.value; }), _a);
+        this.rel.find(op).then(function (val) {
+            var e_4, _a;
+            var _loop_1 = function (value) {
+                value.resolve(val.filter(function (x) {
+                    var ref = (0, getEntityRef_1.getEntityRef)(x);
+                    var field = ref.fields.find(_this.key);
+                    var rel = (0, relationInfoMember_1.getRelationInfo)(field.metadata.options);
+                    var val = (rel === null || rel === void 0 ? void 0 : rel.type) === 'reference'
+                        ? field.getId()
+                        : x[_this.key];
+                    return value.value == val;
+                }));
+            };
+            try {
+                for (var _b = tslib_1.__values(_this.values.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var value = _c.value;
+                    _loop_1(value);
+                }
+            }
+            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; }
+            }
+        }, function (err) {
+            var e_5, _a;
+            try {
+                for (var _b = tslib_1.__values(_this.values.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var value = _c.value;
+                    value.reject(err);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        });
+    };
+    PendingInStatements.prototype.find = function (where) {
+        var val = where[this.key];
+        var valHandler = this.values.get(val);
+        if (!valHandler) {
+            var resolve_1;
+            var reject_1;
+            var result = new Promise(function (resolve1, reject1) {
+                resolve_1 = resolve1;
+                reject_1 = reject1;
+            });
+            this.values.set(val, (valHandler = {
+                value: val,
+                resolve: resolve_1,
+                reject: reject_1,
+                result: result,
+            }));
+        }
+        return valHandler.result;
+    };
+    return PendingInStatements;
+}());

package/src/remult3/relationInfoMember.d.ts

@@ -0,0 +1,4 @@
+import type { FieldOptions } from '../column-interfaces';
+import type { RelationInfo } from './remult3';
+export declare const relationInfoMember: unique symbol;
+export declare function getRelationInfo(options: FieldOptions): RelationInfo;

package/src/remult3/relationInfoMember.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelationInfo = exports.relationInfoMember = void 0;
+exports.relationInfoMember = Symbol('relationInfo');
+function getRelationInfo(options) {
+    return options === null || options === void 0 ? void 0 : options[exports.relationInfoMember];
+}
+exports.getRelationInfo = getRelationInfo;

package/src/remult3/repository-internals.d.ts

@@ -0,0 +1,14 @@
+import type { EntityDataProviderFindOptions } from '../data-interfaces';
+import type { Filter } from '../filter/filter-interfaces';
+import type { EntityFilter, EntityOrderBy, FindOptions, LoadOptions, Repository } from './remult3';
+export interface RepositoryInternal<entityType> {
+    createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
+    fromJsonArray(jsonItems: any[], loadOptions: LoadOptions<entityType>): Promise<entityType[]>;
+    buildEntityDataProviderFindOptions(options: FindOptions<entityType>): Promise<EntityDataProviderFindOptions>;
+    translateWhereToFilter(where: EntityFilter<entityType>): Promise<Filter>;
+    getCachedById(id: any, doNotLoadIfNotFound: boolean): entityType;
+    getCachedByIdAsync(id: any, doNotLoadIfNotFound: boolean): Promise<entityType>;
+    addToCache(item: entityType): any;
+}
+export declare function getRepositoryInternals<entityType>(repo: Repository<entityType>): RepositoryInternal<entityType>;
+export declare const getInternalKey = "getInternal";

package/src/remult3/repository-internals.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInternalKey = exports.getRepositoryInternals = void 0;
+function getRepositoryInternals(repo) {
+    var x = repo;
+    if (typeof x[exports.getInternalKey] === 'function')
+        return x[exports.getInternalKey]();
+    throw Error('Error getting repository internal from ' + repo);
+}
+exports.getRepositoryInternals = getRepositoryInternals;
+exports.getInternalKey = 'getInternal';

package/src/server-action.js

@@ -439,7 +439,7 @@ function BackendMethod(options) {
                                     http])];
                             case 4:
                                 r = _h.sent();
-                                return [4 /*yield*/, defs._updateEntityBasedOnApi(r.rowInfo.data)];
+                                return [4 /*yield*/, defs._updateEntityBasedOnApi(r.rowInfo.data, true)];
                             case 5:
                                 _h.sent();
                                 return [2 /*return*/, r.result];