remult 0.22.1 → 0.22.3

package/src/remult3/RepositoryImplementation.js

@@ -3018,21 +3018,23 @@ function decorateColumnSettings(settings, remult) {
                             isIdNumeric_1 =
                                 remult.repo(settings.valueType).metadata.idMetadata.field
                                     .valueType === Number;
-                            try {
-                                for (var _b = tslib_1.__values([
-                                    'fieldTypeInDb',
-                                ]), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                    var key = _c.value;
-                                    //@ts-ignore
-                                    target[key] = valueConverters_1.ValueConverters.Integer[key];
-                                }
-                            }
-                            catch (e_40_1) { e_40 = { error: e_40_1 }; }
-                            finally {
+                            if (isIdNumeric_1) {
                                 try {
-                                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                    for (var _b = tslib_1.__values([
+                                        'fieldTypeInDb',
+                                    ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                        var key = _c.value;
+                                        //@ts-ignore
+                                        target[key] = valueConverters_1.ValueConverters.Integer[key];
+                                    }
+                                }
+                                catch (e_40_1) { e_40 = { error: e_40_1 }; }
+                                finally {
+                                    try {
+                                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                    }
+                                    finally { if (e_40) throw e_40.error; }
                                 }
-                                finally { if (e_40) throw e_40.error; }
                             }
                         }
                     }

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

@@ -2377,3 +2377,67 @@ db_tests_setup_1.testAll('test relation to number id', function (_a) {
         });
     });
 }, false, { exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans] });
+db_tests_setup_1.testAll('test relation to string id', function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var category, task, catRepo, taskRepo, cat, _b, _c, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    category = /** @class */ (function () {
+                        function class_12() {
+                            this.id = '';
+                            this.name = '';
+                        }
+                        return class_12;
+                    }());
+                    DecoratorReplacer_1.describeClass(category, remult3_1.Entity('rel_ID_string_categories', { allowApiCrud: true }), {
+                        id: remult3_1.Fields.cuid(),
+                        name: remult3_1.Fields.string(),
+                    });
+                    task = /** @class */ (function () {
+                        function class_13() {
+                            this.id = 0;
+                            this.title = '';
+                        }
+                        return class_13;
+                    }());
+                    DecoratorReplacer_1.describeClass(task, remult3_1.Entity('rel_ID_string_task', { allowApiCrud: true }), {
+                        id: remult3_1.Fields.autoIncrement(),
+                        title: remult3_1.Fields.string(),
+                        category: remult3_1.Field(function () { return category; }),
+                    });
+                    return [4 /*yield*/, createEntity(category)];
+                case 1:
+                    catRepo = _e.sent();
+                    return [4 /*yield*/, createEntity(task)];
+                case 2:
+                    taskRepo = _e.sent();
+                    return [4 /*yield*/, catRepo.insert([{ name: 'cat0' }, { name: 'cat1' }])];
+                case 3:
+                    cat = _e.sent();
+                    return [4 /*yield*/, taskRepo.insert([
+                            { title: 't1', category: cat[0] },
+                            { title: 't2', category: cat[0] },
+                            { title: 't3', category: cat[1] },
+                        ])];
+                case 4:
+                    _e.sent();
+                    expect(taskRepo.fields.category.valueConverter.fieldTypeInDb).toBeUndefined();
+                    _b = expect;
+                    return [4 /*yield*/, taskRepo.count({ category: cat[0] })];
+                case 5:
+                    _b.apply(void 0, [_e.sent()]).toBe(2);
+                    _c = expect;
+                    return [4 /*yield*/, taskRepo.count({ category: cat[1] })];
+                case 6:
+                    _c.apply(void 0, [_e.sent()]).toBe(1);
+                    _d = expect;
+                    return [4 /*yield*/, taskRepo.count({ category: { $id: cat[0].id } })];
+                case 7:
+                    _d.apply(void 0, [_e.sent()]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false, { exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans] });

package/{esm/core/src/valueConverters.d.ts → valueConverters.d.ts}

@@ -1,13 +1,12 @@
-import { ValueConverter } from "./column-interfaces";
-export declare class ValueConverters {
-    static readonly Date: ValueConverter<Date>;
-    static readonly DateOnly: ValueConverter<Date>;
-    static readonly DateOnlyString: ValueConverter<Date>;
-    static readonly Boolean: ValueConverter<Boolean>;
-    static readonly Number: ValueConverter<number>;
-    static readonly String: ValueConverter<String>;
-    static readonly Integer: ValueConverter<number>;
-    static readonly Default: Required<ValueConverter<any>>;
-    static readonly JsonString: ValueConverter<any>;
-    static readonly JsonValue: ValueConverter<any>;
-}
+import { ValueConverter } from "./src/column-interfaces";
+export declare class ValueConverters {
+    static readonly Date: ValueConverter<Date>;
+    static readonly DateOnly: ValueConverter<Date>;
+    static readonly DateOnlyString: ValueConverter<Date>;
+    static readonly Boolean: ValueConverter<Boolean>;
+    static readonly Number: ValueConverter<number>;
+    static readonly Integer: ValueConverter<number>;
+    static readonly Default: ValueConverter<any>;
+    static readonly JsonString: ValueConverter<any>;
+    static readonly JsonValue: ValueConverter<any>;
+}

package/valueConverters.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueConverters = void 0;
+var tslib_1 = require("tslib");
+var inputTypes_1 = require("./inputTypes");
+var ValueConverters = /** @class */ (function () {
+    function ValueConverters() {
+    }
+    ValueConverters.Date = {
+        toJson: function (val) {
+            if (!val)
+                return '';
+            if (typeof (val) === "string")
+                val = new Date(val);
+            if (val instanceof Date) {
+                return val.toISOString();
+            }
+            else {
+                console.log("ToJsonError", val);
+                throw new Error("Expected date but got val");
+            }
+        },
+        fromJson: function (val) {
+            if (val == undefined)
+                return undefined;
+            if (val == '')
+                return undefined;
+            if (val.startsWith('0000-00-00'))
+                return undefined;
+            return new Date(Date.parse(val));
+        },
+        toDb: function (x) { return x; },
+        fromDb: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.Date.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Date.toJson(x); },
+        displayValue: function (val) {
+            if (!val)
+                return '';
+            return val.toLocaleString();
+        }
+    };
+    ValueConverters.DateOnly = {
+        fromInput: function (x) { return ValueConverters.DateOnly.fromJson(x); },
+        toInput: function (x) { return ValueConverters.DateOnly.toJson(x); },
+        toJson: function (val) {
+            var d = val;
+            if (typeof d === "string" || typeof (d) === "number")
+                d = new Date(d);
+            if (!d || d == null)
+                return null;
+            if (d.getHours() == 0)
+                return new Date(d.valueOf() - d.getTimezoneOffset() * 60000).toISOString().substring(0, 10);
+            else
+                return d.toISOString().substring(0, 10);
+        },
+        fromJson: function (value) {
+            if (!value || value == '' || value == '0000-00-00')
+                return null;
+            var d = new Date(Date.parse(value));
+            d.setMinutes(d.getMinutes() + d.getTimezoneOffset());
+            return d;
+        },
+        inputType: inputTypes_1.InputTypes.date,
+        toDb: function (val) {
+            if (!val)
+                return null;
+            return ValueConverters.DateOnly.fromJson(ValueConverters.DateOnly.toJson(val));
+        } //when using date storage,  the database expects and returns a date local and every where else we reflect on date iso
+        ,
+        fromDb: function (val) {
+            var d = val;
+            if (!d)
+                return null;
+            return val;
+        },
+        fieldTypeInDb: 'date',
+        displayValue: function (value) {
+            if (!value)
+                return '';
+            return value.toLocaleDateString(undefined);
+        }
+    };
+    ValueConverters.DateOnlyString = tslib_1.__assign(tslib_1.__assign({}, ValueConverters.DateOnly), { toDb: function (d) {
+            var val = ValueConverters.DateOnly.toJson(d);
+            if (!val)
+                return undefined;
+            return val.replace(/-/g, '');
+        }, fromDb: function (val) {
+            if (val === null)
+                return null;
+            if (!val)
+                return undefined;
+            return new Date(val.substring(0, 4) + '-' + val.substring(4, 6) + '-' + val.substring(6, 8));
+        } });
+    ValueConverters.Boolean = {
+        toDb: function (val) { return val; },
+        inputType: inputTypes_1.InputTypes.checkbox,
+        fromDb: function (value) {
+            return ValueConverters.Boolean.fromJson(value);
+        },
+        fromJson: function (value) {
+            if (typeof value === "boolean")
+                return value;
+            if (value !== undefined && value !== null) {
+                return value.toString().trim().toLowerCase() == 'true';
+            }
+            return value;
+        },
+        toJson: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.Boolean.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Boolean.toJson(x); }
+    };
+    ValueConverters.Number = {
+        fromDb: function (value) {
+            if (value === null)
+                return null;
+            if (value !== undefined)
+                return +value;
+            return undefined;
+        },
+        toDb: function (value) { return value; },
+        fromJson: function (value) { return ValueConverters.Number.fromDb(value); },
+        toJson: function (value) { return ValueConverters.Number.toDb(value); },
+        fromInput: function (x, type) {
+            var r = +x;
+            if (!x)
+                return undefined;
+            return r;
+        },
+        toInput: function (x, type) {
+            return x === null || x === void 0 ? void 0 : x.toString();
+        },
+        inputType: inputTypes_1.InputTypes.number
+    };
+    ValueConverters.Integer = tslib_1.__assign(tslib_1.__assign({}, ValueConverters.Number), { toJson: function (value) {
+            var val = ValueConverters.Number.toDb(value);
+            if (!val)
+                return val;
+            return +(+val).toFixed(0);
+        }, toDb: function (value) { return ValueConverters.Integer.toJson(value); }, fieldTypeInDb: 'integer' });
+    ValueConverters.Default = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return ValueConverters.JsonString.fromDb(x); },
+        toDb: function (x) { return ValueConverters.JsonString.toDb(x); },
+        fromInput: function (x) { return ValueConverters.Default.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Default.toJson(x); }
+    };
+    ValueConverters.JsonString = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return x == null ? null : x ? JSON.parse(ValueConverters.JsonString.fromJson(x)) : undefined; },
+        toDb: function (x) { return x !== undefined ? x === null ? null : JSON.stringify(ValueConverters.JsonString.toJson(x)) : undefined; },
+        fromInput: function (x) { return ValueConverters.JsonString.fromJson(x); },
+        toInput: function (x) { return ValueConverters.JsonString.toJson(x); }
+    };
+    ValueConverters.JsonValue = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return x; },
+        toDb: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.JsonString.fromJson(x); },
+        toInput: function (x) { return ValueConverters.JsonString.toJson(x); },
+        fieldTypeInDb: 'json'
+    };
+    return ValueConverters;
+}());
+exports.ValueConverters = ValueConverters;

package/esm/angular/interfaces/index.d.ts

@@ -1 +0,0 @@
-export * from './src/public_api';

package/esm/angular/interfaces/index.js

@@ -1 +0,0 @@
-export * from './src/public_api';

package/esm/angular/interfaces/src/column-collection.d.ts

@@ -1,70 +0,0 @@
-import { FieldMetadata, FieldRef, EntityMetadata, ValueListItem, Remult, Repository, EntityOrderBy, EntityFilter } from "remult";
-import { DataControlInfo, DataControlSettings, ValueOrEntityExpression } from "./data-control-interfaces";
-import { FilterHelper } from "./filter-helper";
-export declare class FieldCollection<rowType = any> {
-    currentRow: () => any;
-    private allowUpdate;
-    filterHelper: FilterHelper<rowType>;
-    private showArea;
-    private _getRowColumn;
-    constructor(currentRow: () => any, allowUpdate: () => boolean, filterHelper: FilterHelper<rowType>, showArea: () => boolean, _getRowColumn: (row: rowType, col: FieldMetadata) => FieldRef<any, any>);
-    __showArea(): boolean;
-    __getColumn(map: DataControlSettings, record: any): any;
-    __visible(col: DataControlSettings, row: any): boolean;
-    allowClick(col: DataControlSettings<any, any>, row: any): boolean;
-    getRowColumn<T>(args: {
-        col: DataControlSettings<any>;
-        row: any;
-    }, what: (c: FieldRef<any, any>, row: any) => T): T;
-    __dataControlStyle(map: DataControlSettings): string;
-    private settingsByKey;
-    allowDesignMode: boolean;
-    add(...columns: DataControlInfo<rowType>[]): Promise<void>;
-    add(...columns: string[]): Promise<void>;
-    private doWhenWeHaveContext;
-    private remult;
-    setContext(remult: Remult): void;
-    buildDropDown(s: DataControlSettings): Promise<void>;
-    designMode: boolean;
-    colListChanged(): void;
-    _colListChangeListeners: (() => void)[];
-    onColListChange(action: (() => void)): void;
-    moveCol(col: DataControlSettings, move: number): void;
-    filterRows(col: DataControlSettings): void;
-    clearFilter(col: DataControlSettings): void;
-    _shouldShowFilterDialog(col: DataControlSettings): boolean;
-    deleteCol(col: DataControlSettings): void;
-    addCol(col: DataControlSettings, newCol: DataControlSettings): void;
-    _getEditable(col: DataControlSettings, row: rowType): boolean;
-    _click(col: DataControlSettings, row: any): void;
-    _getColDisplayValue(col: DataControlSettings, row: rowType): any;
-    _getColDataType(col: DataControlSettings): string;
-    _getColumnClass(col: DataControlSettings, row: any): any;
-    _getError(col: DataControlSettings, r: any): any;
-    autoGenerateColumnsBasedOnData(defs: EntityMetadata<any>): void;
-    __changeWidth(col: DataControlSettings, what: number): void;
-    _colValueChanged(col: DataControlSettings, row: any): false | undefined;
-    items: DataControlSettings[];
-    private gridColumns;
-    private nonGridColumns;
-    numOfColumnsInGrid: number;
-    private _lastColumnCount;
-    private _lastNumOfColumnsInGrid;
-    private augmented;
-    augment(augmenter: dataControlAugmenter, s: DataControlSettings): void;
-    private _initColumnsArrays;
-    getGridColumns(augmenter: dataControlAugmenter): DataControlSettings<any, any>[];
-    getNonGridColumns(augmenter: dataControlAugmenter): DataControlSettings<any, any>[];
-}
-export declare function valueOrEntityExpressionToValue<T, entityType>(f: ValueOrEntityExpression<T, entityType>, e: entityType): T;
-/** returns an array of values that can be used in the value list property of a data control object */
-export declare function getEntityValueList<T>(repository: Repository<T>, args?: {
-    idField?: (e: EntityMetadata<T>) => FieldMetadata;
-    captionField?: (e: EntityMetadata<T>) => FieldMetadata;
-    orderBy?: EntityOrderBy<T>;
-    where?: EntityFilter<T>;
-}): Promise<ExtendedValueListItem[]>;
-export interface ExtendedValueListItem extends ValueListItem {
-    entity?: any;
-}
-export declare type dataControlAugmenter = (f: FieldMetadata, op: DataControlSettings) => void;