remult 0.25.8-exp.8 → 0.25.8-exp.9

package/esm/server/initAsyncHooks.js

@@ -6,5 +6,80 @@ export function initAsyncHooks() {
     if (init)
         return;
     init = true;
-    remultStatic.asyncContext = new RemultAsyncLocalStorage(new AsyncLocalStorage());
+    remultStatic.asyncContext = new RemultAsyncLocalStorage(new AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore());
+    let test = new AsyncLocalStorage();
+    test.run(1, async () => {
+        await Promise.resolve();
+        if (test.getStore() === undefined) {
+            console.log("async_hooks.AsyncLocalStorage not working, using sequential implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
+            remultStatic.asyncContext = new RemultAsyncLocalStorage(new SequentialRemultAsyncLocalStorageCore());
+        }
+    });
+}
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
+    asyncLocalStorage = new AsyncLocalStorage();
+    wasImplemented;
+    run(store, callback) {
+        let r;
+        this.asyncLocalStorage.run(store, () => {
+            r = new Promise(async (res, rej) => {
+                try {
+                    res(await callback());
+                }
+                catch (err) {
+                    rej(err);
+                }
+            });
+        });
+        return r;
+    }
+    getStore() {
+        return this.asyncLocalStorage.getStore();
+    }
+}
+const ignoreInStack = ["AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run", "RemultAsyncLocalStorage.run", "Module.withRemult", "RemultServerImplementation.runWithRemult"];
+export class SequentialRemultAsyncLocalStorageCore {
+    wasImplemented;
+    async run(store, callback) {
+        let log = (msg) => {
+            console.log(msg);
+        };
+        if (false) {
+            let stack = new Error().stack;
+            let y = stack.split('\n');
+            while (y.length > 0 && (y[0].trim().startsWith("Error") || ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
+                y.splice(0, 1);
+            }
+            stack = y.join('\n');
+            log = (msg) => {
+                console.log(msg, stack);
+            };
+        }
+        log('waiting on ');
+        const nextPromise = this.lastPromise.then(async () => {
+            log('executing  ');
+            const previousValue = this.currentValue;
+            this.currentValue = store;
+            const result = await callback();
+            this.currentValue = previousValue;
+            return result;
+        });
+        this.lastPromise = nextPromise.catch(() => {
+            log("Error on ");
+            return undefined;
+        });
+        try {
+            return await nextPromise;
+        }
+        finally {
+            log('completed  ');
+        }
+    }
+    getStore() {
+        return this.currentValue;
+    }
+    lastPromise = Promise.resolve(undefined);
+    currentValue;
+}
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
 }

package/esm/src/context.js

@@ -24,11 +24,12 @@ export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
-    run(remult, callback) {
-        if (this.remultObjectStorage)
-            this.remultObjectStorage.run(remult, () => callback(remult));
+    async run(remult, callback) {
+        if (this.remultObjectStorage) {
+            return this.remultObjectStorage.run(remult, () => callback(remult));
+        }
         else
-            callback(remult);
+            return callback(remult);
     }
     getRemult() {
         if (!this.remultObjectStorage) {
@@ -285,16 +286,5 @@ export function withRemult(callback, options) {
     const remult = new Remult();
     if (options?.dataProvider)
         remult.dataProvider = options.dataProvider;
-    let r;
-    remultStatic.asyncContext.run(remult, () => {
-        r = new Promise(async (res, rej) => {
-            try {
-                res(await callback(remult));
-            }
-            catch (err) {
-                rej(err);
-            }
-        });
-    });
-    return r;
+    return remultStatic.asyncContext.run(remult, r => callback(r));
 }

package/esm/src/remult3/Fields.js

@@ -2,10 +2,13 @@ import { createId } from '@paralleldrive/cuid2';
 import { v4 as uuid } from 'uuid';
 import { ValueConverters } from '../valueConverters.js';
 import { buildOptions } from './RepositoryImplementation.js';
-import { Validators } from '../validators.js';
+import { Validators, createValueValidator, getEnumValues } from '../validators.js';
 import { relationInfoMemberInOptions } from './relationInfoMember.js';
 import { remultStatic } from '../remult-static.js';
-import { addValidatorKey } from './addValidatorKey.js';
+import { addValidator } from './addValidator.js';
+const validateNumber = createValueValidator((x) => {
+    return !isNaN(x) && isFinite(x);
+});
 export class Fields {
     /**
      * Stored as a JSON.stringify - to store as json use Fields.json
@@ -35,6 +38,7 @@ export class Fields {
     static integer(...options) {
         return Field(() => Number, {
             valueConverter: ValueConverters.Integer,
+            validate: validateNumber,
         }, ...options);
     }
     static autoIncrement(...options) {
@@ -48,7 +52,9 @@ export class Fields {
         }, ...options);
     }
     static number(...options) {
-        return Field(() => Number, ...options);
+        return Field(() => Number, {
+            validate: validateNumber,
+        }, ...options);
     }
     static createdAt(...options) {
         return Field(() => Date, {
@@ -123,8 +129,7 @@ export class Fields {
    */
     static literal(optionalValues, ...options) {
         return Fields.string({
-            //@ts-ignore
-            [addValidatorKey]: (entity, event) => Validators.in(optionalValues())(entity, event)
+            validate: (entity, event) => Validators.in(optionalValues())(entity, event)
         }, ...options);
     }
     static enum(enumType, ...options) {
@@ -132,12 +137,11 @@ export class Fields {
         return Field(() => 
         //@ts-ignore
         enumType(), {
-            [addValidatorKey]: (entity, event) => Validators.enum(enumType())(entity, event)
+            validate: (entity, event) => Validators.enum(enumType())(entity, event)
         }, ...options, (options) => {
             if (valueConverter === undefined) {
                 let enumObj = enumType();
-                let enumValues = Object.values(enumObj)
-                    .filter((x) => typeof enumObj[x] !== 'number');
+                let enumValues = getEnumValues(enumObj);
                 valueConverter = enumValues.find(x => typeof x === "string") ? ValueConverters.String : ValueConverters.Integer;
             }
             if (!options.valueConverter) {
@@ -249,10 +253,7 @@ export function Field(valueType, ...options) {
         let factory = (remult) => {
             let r = buildOptions(options, remult);
             if (r.required) {
-                r.validate = addValidator(r.validate, Validators.required);
-            }
-            if (r[addValidatorKey]) {
-                r.validate = addValidator(r.validate, r[addValidatorKey]);
+                r.validate = addValidator(r.validate, Validators.required, true);
             }
             if (r.maxLength) {
                 r.validate = addValidator(r.validate, Validators.maxLength(r.maxLength));
@@ -306,18 +307,3 @@ export function checkTarget(target) {
     if (!target)
         throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
 }
-function addValidator(validators, newValidator, atStart = false) {
-    if (!newValidator)
-        return;
-    const newValidators = Array.isArray(newValidator)
-        ? newValidator
-        : [newValidator];
-    const validatorsArray = Array.isArray(validators)
-        ? validators
-        : validators
-            ? [validators]
-            : [];
-    return atStart
-        ? [...newValidators, ...validatorsArray]
-        : [...validatorsArray, ...newValidators];
-}

package/esm/src/remult3/RepositoryImplementation.js

@@ -15,6 +15,7 @@ import { getInternalKey, } from './repository-internals.js';
 import { entityDbName, fieldDbName, } from '../filter/filter-consumer-bridge-to-sql-request.js';
 import { remultStatic } from '../remult-static.js';
 import { Validators } from '../validators.js';
+import { addValidator } from './addValidator.js';
 //import  { remult } from "../remult-proxy";
 let classValidatorValidate = undefined;
 // import ("class-validator".toString())
@@ -2074,8 +2075,11 @@ export function buildOptions(options, remult) {
         if (o) {
             if (typeof o === 'function')
                 o(r, remult);
-            else
-                Object.assign(r, o);
+            else {
+                const { validate, ...otherOptions } = o;
+                r.validate = addValidator(r.validate, validate);
+                Object.assign(r, otherOptions);
+            }
         }
     }
     return r;
@@ -2084,10 +2088,7 @@ export function decorateColumnSettings(settings, remult) {
     if (settings.valueType) {
         let settingsOnTypeLevel = settings.valueType[storableMember];
         if (settingsOnTypeLevel) {
-            settings = {
-                ...buildOptions(settingsOnTypeLevel, remult),
-                ...settings,
-            };
+            settings = buildOptions([...settingsOnTypeLevel, settings], remult);
         }
     }
     if (settings.valueType == String) {

package/esm/src/remult3/addValidator.js

@@ -0,0 +1,15 @@
+export function addValidator(validators, newValidator, atStart = false) {
+    if (!newValidator)
+        return validators;
+    const newValidators = Array.isArray(newValidator)
+        ? newValidator
+        : [newValidator];
+    const validatorsArray = Array.isArray(validators)
+        ? validators
+        : validators
+            ? [validators]
+            : [];
+    return atStart
+        ? [...newValidators, ...validatorsArray]
+        : [...validatorsArray, ...newValidators];
+}

package/esm/src/remult3/remult3.js

@@ -1,12 +1,12 @@
 export {};
 //p1 - `preprocessApiFindOptions`,  naming - allow find options preprocessor for api calls, to use for authorization
 //p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
-//p1 - Validate for NAN
 //p1 - Make async hooks gracefully handle non async hooks environment
-//p1 - chain validators with options
+//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
+//p1 - article auth.js with express
+//p1 - document offline support
 //y2 - should we validate relations
 //y1 - consider replacing all errors with error classes that extend the base Error class
-//y2 - consider if field types should include validation in them by default (string,number that it's not NaN etc...) and if so, what message?
 //y2 - should enforce integer - currently we probably round / truncate it
 /*y1 - talk about modules in init express with entities/controllers,initRequest,initApi
  - support get with backend method, with url search params as the first parameter, & url as second parameter
@@ -14,8 +14,6 @@ export {};
 
  */
 //p1 - in this video I'll use remult to turn a frontend app to a fullstack app
-//y1 - getFields didn't work for kobi in the home component
-//p1 - document offline support
 /*y1 - Talk JYC - JYC - add some integrity checks on delete
   - soft delete
   - delete restrict (implicit, or user selected - and if so, how) (delete & update of id)

package/esm/src/validators.js

@@ -28,8 +28,7 @@ export class Validators {
     static url = createValueValidator((val) => !!new URL(val), 'Invalid Url');
     static in = createValueValidatorWithArgs((val, values) => values.includes(val), (values) => `Value must be one of ${values.map(y => typeof y === "object" ? y['id'] !== undefined ? y['id'] : y.toString() : y).join(', ')}`);
     static notNull = createValueValidator((val) => val != null, 'Should not be null');
-    static enum = createValueValidatorWithArgs((value, enumObj) => Object.values(enumObj).includes(value), (enumObj) => `Value must be one of ${Object.values(enumObj)
-        .filter((x) => typeof enumObj[x] !== 'number')
+    static enum = createValueValidatorWithArgs((value, enumObj) => Object.values(enumObj).includes(value), (enumObj) => `Value must be one of ${getEnumValues(enumObj)
         .join(', ')}`);
     static relationExists = createValidator(async (_, e) => {
         if (e.valueIsNull())
@@ -134,3 +133,7 @@ function createValidatorWithArgsInternal(validate, defaultMessage, isValueValida
         },
     });
 }
+export function getEnumValues(enumObj) {
+    return Object.values(enumObj)
+        .filter((x) => typeof enumObj[x] !== 'number');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.25.8-exp.8",
+    "version": "0.25.8-exp.9",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/server/initAsyncHooks.d.ts

@@ -1 +1,17 @@
+import { type RemultAsyncLocalStorageCore } from '../src/context.js';
 export declare function initAsyncHooks(): void;
+export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> implements RemultAsyncLocalStorageCore<T> {
+    private asyncLocalStorage;
+    wasImplemented: 'yes';
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T;
+}
+export declare class SequentialRemultAsyncLocalStorageCore<T> implements RemultAsyncLocalStorageCore<T> {
+    wasImplemented: 'yes';
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T;
+    lastPromise: Promise<T>;
+    currentValue: T;
+}
+export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore<T> extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> {
+}

package/server/initAsyncHooks.js

@@ -1,14 +1,141 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initAsyncHooks = void 0;
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.SequentialRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = exports.initAsyncHooks = void 0;
+var tslib_1 = require("tslib");
 var async_hooks_1 = require("async_hooks");
 var context_js_1 = require("../src/context.js");
 var remult_static_js_1 = require("../src/remult-static.js");
 var init = false;
 function initAsyncHooks() {
+    var _this = this;
     if (init)
         return;
     init = true;
-    remult_static_js_1.remultStatic.asyncContext = new context_js_1.RemultAsyncLocalStorage(new async_hooks_1.AsyncLocalStorage());
+    remult_static_js_1.remultStatic.asyncContext = new context_js_1.RemultAsyncLocalStorage(new AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore());
+    var test = new async_hooks_1.AsyncLocalStorage();
+    test.run(1, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve()];
+                case 1:
+                    _a.sent();
+                    if (test.getStore() === undefined) {
+                        console.log("async_hooks.AsyncLocalStorage not working, using sequential implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
+                        remult_static_js_1.remultStatic.asyncContext = new context_js_1.RemultAsyncLocalStorage(new SequentialRemultAsyncLocalStorageCore());
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 }
 exports.initAsyncHooks = initAsyncHooks;
+var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = /** @class */ (function () {
+    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl() {
+        this.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+    }
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.run = function (store, callback) {
+        var _this = this;
+        var r;
+        this.asyncLocalStorage.run(store, function () {
+            r = new Promise(function (res, rej) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var _a, err_1;
+                return tslib_1.__generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 2, , 3]);
+                            _a = res;
+                            return [4 /*yield*/, callback()];
+                        case 1:
+                            _a.apply(void 0, [_b.sent()]);
+                            return [3 /*break*/, 3];
+                        case 2:
+                            err_1 = _b.sent();
+                            rej(err_1);
+                            return [3 /*break*/, 3];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        return r;
+    };
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.getStore = function () {
+        return this.asyncLocalStorage.getStore();
+    };
+    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
+}());
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
+var ignoreInStack = ["AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run", "RemultAsyncLocalStorage.run", "Module.withRemult", "RemultServerImplementation.runWithRemult"];
+var SequentialRemultAsyncLocalStorageCore = /** @class */ (function () {
+    function SequentialRemultAsyncLocalStorageCore() {
+        this.lastPromise = Promise.resolve(undefined);
+    }
+    SequentialRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var log, stack_1, y, nextPromise;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        log = function (msg) {
+                            console.log(msg);
+                        };
+                        if (false) {
+                            stack_1 = new Error().stack;
+                            y = stack_1.split('\n');
+                            while (y.length > 0 && (y[0].trim().startsWith("Error") || ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
+                                y.splice(0, 1);
+                            }
+                            stack_1 = y.join('\n');
+                            log = function (msg) {
+                                console.log(msg, stack_1);
+                            };
+                        }
+                        log('waiting on ');
+                        nextPromise = this.lastPromise.then(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var previousValue, result;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        log('executing  ');
+                                        previousValue = this.currentValue;
+                                        this.currentValue = store;
+                                        return [4 /*yield*/, callback()];
+                                    case 1:
+                                        result = _a.sent();
+                                        this.currentValue = previousValue;
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); });
+                        this.lastPromise = nextPromise.catch(function () {
+                            log("Error on ");
+                            return undefined;
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, nextPromise];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        log('completed  ');
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SequentialRemultAsyncLocalStorageCore.prototype.getStore = function () {
+        return this.currentValue;
+    };
+    return SequentialRemultAsyncLocalStorageCore;
+}());
+exports.SequentialRemultAsyncLocalStorageCore = SequentialRemultAsyncLocalStorageCore;
+var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (function (_super) {
+    tslib_1.__extends(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore, _super);
+    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
+}(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl));
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;

package/src/context.d.ts

@@ -8,13 +8,14 @@ export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;
     static disable(): void;
-    constructor(remultObjectStorage: myAsyncLocalStorage<Remult>);
-    run(remult: Remult, callback: (remult: Remult) => void): void;
+    constructor(remultObjectStorage: RemultAsyncLocalStorageCore<Remult>);
+    run<T>(remult: Remult, callback: (remult: Remult) => Promise<T>): Promise<T>;
     getRemult(): Remult;
 }
-type myAsyncLocalStorage<T> = {
-    run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
+export type RemultAsyncLocalStorageCore<T> = {
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
     getStore(): T | undefined;
+    wasImplemented: 'yes';
 };
 export declare function isBackend(): boolean;
 export declare class Remult {
@@ -189,4 +190,3 @@ export declare function doTransaction(remult: Remult, what: (dp: DataProvider) =
 export declare function withRemult<T>(callback: (remult: any) => Promise<T>, options?: {
     dataProvider?: DataProvider;
 }): Promise<T>;
-export {};

package/src/context.js

@@ -28,10 +28,16 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
         (0, remult_static_js_1.resetFactory)();
     };
     RemultAsyncLocalStorage.prototype.run = function (remult, callback) {
-        if (this.remultObjectStorage)
-            this.remultObjectStorage.run(remult, function () { return callback(remult); });
-        else
-            callback(remult);
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (this.remultObjectStorage) {
+                    return [2 /*return*/, this.remultObjectStorage.run(remult, function () { return callback(remult); })];
+                }
+                else
+                    return [2 /*return*/, callback(remult)];
+                return [2 /*return*/];
+            });
+        });
     };
     RemultAsyncLocalStorage.prototype.getRemult = function () {
         if (!this.remultObjectStorage) {
@@ -449,32 +455,9 @@ var transactionLiveQueryPublisher = /** @class */ (function () {
     return transactionLiveQueryPublisher;
 }());
 function withRemult(callback, options) {
-    var _this = this;
     var remult = new Remult();
     if (options === null || options === void 0 ? void 0 : options.dataProvider)
         remult.dataProvider = options.dataProvider;
-    var r;
-    remult_static_js_1.remultStatic.asyncContext.run(remult, function () {
-        r = new Promise(function (res, rej) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var _a, err_1;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        _a = res;
-                        return [4 /*yield*/, callback(remult)];
-                    case 1:
-                        _a.apply(void 0, [_b.sent()]);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        err_1 = _b.sent();
-                        rej(err_1);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    return r;
+    return remult_static_js_1.remultStatic.asyncContext.run(remult, function (r) { return callback(r); });
 }
 exports.withRemult = withRemult;

package/src/remult3/Fields.js

@@ -9,7 +9,10 @@ var RepositoryImplementation_js_1 = require("./RepositoryImplementation.js");
 var validators_js_1 = require("../validators.js");
 var relationInfoMember_js_1 = require("./relationInfoMember.js");
 var remult_static_js_1 = require("../remult-static.js");
-var addValidatorKey_js_1 = require("./addValidatorKey.js");
+var addValidator_js_1 = require("./addValidator.js");
+var validateNumber = (0, validators_js_1.createValueValidator)(function (x) {
+    return !isNaN(x) && isFinite(x);
+});
 var Fields = /** @class */ (function () {
     function Fields() {
     }
@@ -64,6 +67,7 @@ var Fields = /** @class */ (function () {
         return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; },
             {
                 valueConverter: valueConverters_js_1.ValueConverters.Integer,
+                validate: validateNumber,
             }], tslib_1.__read(options), false));
     };
     Fields.autoIncrement = function () {
@@ -83,7 +87,9 @@ var Fields = /** @class */ (function () {
         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));
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; }, {
+                validate: validateNumber,
+            }], tslib_1.__read(options), false));
     };
     Fields.createdAt = function () {
         var options = [];
@@ -178,18 +184,15 @@ var Fields = /** @class */ (function () {
    * // This approach allows easy management and updates of the allowed values for the `status` field.
    */
     Fields.literal = function (optionalValues) {
-        var _a;
         var options = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             options[_i - 1] = arguments[_i];
         }
-        return Fields.string.apply(Fields, tslib_1.__spreadArray([(_a = {},
-                //@ts-ignore
-                _a[addValidatorKey_js_1.addValidatorKey] = function (entity, event) { return validators_js_1.Validators.in(optionalValues())(entity, event); },
-                _a)], tslib_1.__read(options), false));
+        return Fields.string.apply(Fields, tslib_1.__spreadArray([{
+                validate: function (entity, event) { return validators_js_1.Validators.in(optionalValues())(entity, event); }
+            }], tslib_1.__read(options), false));
     };
     Fields.enum = function (enumType) {
-        var _a;
         var options = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             options[_i - 1] = arguments[_i];
@@ -198,13 +201,13 @@ var Fields = /** @class */ (function () {
         return Field.apply(void 0, tslib_1.__spreadArray(tslib_1.__spreadArray([function () {
                 //@ts-ignore
                 return (enumType());
-            }, (_a = {},
-                _a[addValidatorKey_js_1.addValidatorKey] = function (entity, event) { return validators_js_1.Validators.enum(enumType())(entity, event); },
-                _a)], tslib_1.__read(options), false), [function (options) {
+            },
+            {
+                validate: function (entity, event) { return validators_js_1.Validators.enum(enumType())(entity, event); }
+            }], tslib_1.__read(options), false), [function (options) {
                 if (valueConverter === undefined) {
-                    var enumObj_1 = enumType();
-                    var enumValues = Object.values(enumObj_1)
-                        .filter(function (x) { return typeof enumObj_1[x] !== 'number'; });
+                    var enumObj = enumType();
+                    var enumValues = (0, validators_js_1.getEnumValues)(enumObj);
                     valueConverter = enumValues.find(function (x) { return typeof x === "string"; }) ? valueConverters_js_1.ValueConverters.String : valueConverters_js_1.ValueConverters.Integer;
                 }
                 if (!options.valueConverter) {
@@ -323,16 +326,13 @@ function Field(valueType) {
         var factory = function (remult) {
             var r = (0, RepositoryImplementation_js_1.buildOptions)(options, remult);
             if (r.required) {
-                r.validate = addValidator(r.validate, validators_js_1.Validators.required);
-            }
-            if (r[addValidatorKey_js_1.addValidatorKey]) {
-                r.validate = addValidator(r.validate, r[addValidatorKey_js_1.addValidatorKey]);
+                r.validate = (0, addValidator_js_1.addValidator)(r.validate, validators_js_1.Validators.required, true);
             }
             if (r.maxLength) {
-                r.validate = addValidator(r.validate, validators_js_1.Validators.maxLength(r.maxLength));
+                r.validate = (0, addValidator_js_1.addValidator)(r.validate, validators_js_1.Validators.maxLength(r.maxLength));
             }
             if (r.minLength) {
-                r.validate = addValidator(r.validate, validators_js_1.Validators.minLength(r.minLength));
+                r.validate = (0, addValidator_js_1.addValidator)(r.validate, validators_js_1.Validators.minLength(r.minLength));
             }
             if (!r.valueType && valueType) {
                 r.valueType = valueType();
@@ -382,18 +382,3 @@ function checkTarget(target) {
         throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
 }
 exports.checkTarget = checkTarget;
-function addValidator(validators, newValidator, atStart) {
-    if (atStart === void 0) { atStart = false; }
-    if (!newValidator)
-        return;
-    var newValidators = Array.isArray(newValidator)
-        ? newValidator
-        : [newValidator];
-    var validatorsArray = Array.isArray(validators)
-        ? validators
-        : validators
-            ? [validators]
-            : [];
-    return atStart
-        ? tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(newValidators), false), tslib_1.__read(validatorsArray), false) : tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(validatorsArray), false), tslib_1.__read(newValidators), false);
-}

package/src/remult3/RepositoryImplementation.js

@@ -19,6 +19,7 @@ var repository_internals_js_1 = require("./repository-internals.js");
 var filter_consumer_bridge_to_sql_request_js_1 = require("../filter/filter-consumer-bridge-to-sql-request.js");
 var remult_static_js_1 = require("../remult-static.js");
 var validators_js_1 = require("../validators.js");
+var addValidator_js_1 = require("./addValidator.js");
 //import  { remult } from "../remult-proxy";
 var classValidatorValidate = undefined;
 // import ("class-validator".toString())
@@ -3379,8 +3380,11 @@ function buildOptions(options, remult) {
             if (o) {
                 if (typeof o === 'function')
                     o(r, remult);
-                else
-                    Object.assign(r, o);
+                else {
+                    var validate = o.validate, otherOptions = tslib_1.__rest(o, ["validate"]);
+                    r.validate = (0, addValidator_js_1.addValidator)(r.validate, validate);
+                    Object.assign(r, otherOptions);
+                }
             }
         }
     }
@@ -3398,7 +3402,7 @@ function decorateColumnSettings(settings, remult) {
     if (settings.valueType) {
         var settingsOnTypeLevel = settings.valueType[exports.storableMember];
         if (settingsOnTypeLevel) {
-            settings = tslib_1.__assign(tslib_1.__assign({}, buildOptions(settingsOnTypeLevel, remult)), settings);
+            settings = buildOptions(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(settingsOnTypeLevel), false), [settings], false), remult);
         }
     }
     if (settings.valueType == String) {

package/src/remult3/addValidator.d.ts

@@ -0,0 +1,2 @@
+import type { FieldOptions } from '../column-interfaces.js';
+export declare function addValidator(validators: FieldOptions['validate'], newValidator: FieldOptions['validate'], atStart?: boolean): import("../column-interfaces.js").FieldValidator<any, any> | import("../column-interfaces.js").FieldValidator<any, any>[];

package/src/remult3/addValidator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addValidator = void 0;
+var tslib_1 = require("tslib");
+function addValidator(validators, newValidator, atStart) {
+    if (atStart === void 0) { atStart = false; }
+    if (!newValidator)
+        return validators;
+    var newValidators = Array.isArray(newValidator)
+        ? newValidator
+        : [newValidator];
+    var validatorsArray = Array.isArray(validators)
+        ? validators
+        : validators
+            ? [validators]
+            : [];
+    return atStart
+        ? tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(newValidators), false), tslib_1.__read(validatorsArray), false) : tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(validatorsArray), false), tslib_1.__read(newValidators), false);
+}
+exports.addValidator = addValidator;

package/src/remult3/remult3.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 //p1 - `preprocessApiFindOptions`,  naming - allow find options preprocessor for api calls, to use for authorization
 //p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
-//p1 - Validate for NAN
 //p1 - Make async hooks gracefully handle non async hooks environment
-//p1 - chain validators with options
+//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
+//p1 - article auth.js with express
+//p1 - document offline support
 //y2 - should we validate relations
 //y1 - consider replacing all errors with error classes that extend the base Error class
-//y2 - consider if field types should include validation in them by default (string,number that it's not NaN etc...) and if so, what message?
 //y2 - should enforce integer - currently we probably round / truncate it
 /*y1 - talk about modules in init express with entities/controllers,initRequest,initApi
  - support get with backend method, with url search params as the first parameter, & url as second parameter
@@ -15,8 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 
  */
 //p1 - in this video I'll use remult to turn a frontend app to a fullstack app
-//y1 - getFields didn't work for kobi in the home component
-//p1 - document offline support
 /*y1 - Talk JYC - JYC - add some integrity checks on delete
   - soft delete
   - delete restrict (implicit, or user selected - and if so, how) (delete & update of id)

package/src/validators.d.ts

@@ -47,3 +47,4 @@ export type ValidatorWithArgs<valueType, argsType> = (args: argsType, message?:
 export declare function createValidatorWithArgs<valueType, argsType>(validate: (entity: any, e: ValidateFieldEvent<any, valueType>, args: argsType) => Promise<boolean | string> | boolean | string, defaultMessage: ValidationMessage<valueType, argsType>): ValidatorWithArgs<valueType, argsType> & {
     defaultMessage: ValidationMessage<valueType, argsType>;
 };
+export declare function getEnumValues<theEnum = any>(enumObj: theEnum): any[];

package/src/validators.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createValidatorWithArgs = exports.createValueValidatorWithArgs = exports.createValueValidator = exports.valueValidator = exports.createValidator = exports.Validators = void 0;
+exports.getEnumValues = exports.createValidatorWithArgs = exports.createValueValidatorWithArgs = exports.createValueValidator = exports.valueValidator = exports.createValidator = exports.Validators = void 0;
 var tslib_1 = require("tslib");
 var Validators = /** @class */ (function () {
     function Validators() {
@@ -53,8 +53,7 @@ var Validators = /** @class */ (function () {
     }).join(', ')); });
     Validators.notNull = createValueValidator(function (val) { return val != null; }, 'Should not be null');
     Validators.enum = createValueValidatorWithArgs(function (value, enumObj) { return Object.values(enumObj).includes(value); }, function (enumObj) {
-        return "Value must be one of ".concat(Object.values(enumObj)
-            .filter(function (x) { return typeof enumObj[x] !== 'number'; })
+        return "Value must be one of ".concat(getEnumValues(enumObj)
             .join(', '));
     });
     Validators.relationExists = createValidator(function (_, e) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
@@ -209,3 +208,8 @@ function createValidatorWithArgsInternal(validate, defaultMessage, isValueValida
         },
     });
 }
+function getEnumValues(enumObj) {
+    return Object.values(enumObj)
+        .filter(function (x) { return typeof enumObj[x] !== 'number'; });
+}
+exports.getEnumValues = getEnumValues;

package/esm/src/remult3/addValidatorKey.js

@@ -1 +0,0 @@
-export const addValidatorKey = '__addValidator';

package/src/remult3/addValidatorKey.d.ts

@@ -1 +0,0 @@
-export declare const addValidatorKey = "__addValidator";

package/src/remult3/addValidatorKey.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addValidatorKey = void 0;
-exports.addValidatorKey = '__addValidator';