remult 0.25.8-exp.7 → 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/isOfType.js

@@ -1,5 +1,5 @@
 export function isOfType(obj, checkMethod) {
-    return typeof obj[checkMethod] === 'function';
+    return typeof obj[checkMethod] !== 'undefined';
 }
 export function cast(obj, checkMethod) {
     if (isOfType(obj, checkMethod)) {

package/esm/src/remult3/Fields.js

@@ -2,9 +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 { 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
@@ -34,6 +38,7 @@ export class Fields {
     static integer(...options) {
         return Field(() => Number, {
             valueConverter: ValueConverters.Integer,
+            validate: validateNumber,
         }, ...options);
     }
     static autoIncrement(...options) {
@@ -47,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, {
@@ -76,6 +83,11 @@ export class Fields {
             },
         }, ...options);
     }
+    /**
+   * A CUID (Collision Resistant Unique Identifier) field.
+   * This id value is determined on the backend on insert, and can't be updated through the API.
+   * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+   */
     static cuid(...options) {
         return Field(() => String, {
             allowApiUpdate: false,
@@ -86,6 +98,61 @@ export class Fields {
             },
         }, ...options);
     }
+    /**
+   * Defines a field that can hold a value from a specified set of string literals.
+   * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
+   * @returns {ClassFieldDecorator<entityType, valueType | undefined>} - A class field decorator.
+   *
+   * @example
+   
+   * class MyEntity {
+   *   .@Fields.literal(() => ['open', 'closed', 'frozen', 'in progress'] as const)
+   *   status: 'open' | 'closed' | 'frozen' | 'in progress' = 'open';
+   * }
+   
+   *
+   * // This defines a field `status` in `MyEntity` that can only hold the values 'open', 'closed', 'frozen', or 'in progress'.
+   *
+   * @example
+   * // For better reusability and maintainability:
+   
+   * const statuses = ['open', 'closed', 'frozen', 'in progress'] as const;
+   * type StatusType = typeof statuses[number];
+   *
+   * class MyEntity {
+   *   .@Fields.literal(() => statuses)
+   *   status: StatusType = 'open';
+   * }
+   
+   *
+   * // This approach allows easy management and updates of the allowed values for the `status` field.
+   */
+    static literal(optionalValues, ...options) {
+        return Fields.string({
+            validate: (entity, event) => Validators.in(optionalValues())(entity, event)
+        }, ...options);
+    }
+    static enum(enumType, ...options) {
+        let valueConverter;
+        return Field(() => 
+        //@ts-ignore
+        enumType(), {
+            validate: (entity, event) => Validators.enum(enumType())(entity, event)
+        }, ...options, (options) => {
+            if (valueConverter === undefined) {
+                let enumObj = enumType();
+                let enumValues = getEnumValues(enumObj);
+                valueConverter = enumValues.find(x => typeof x === "string") ? ValueConverters.String : ValueConverters.Integer;
+            }
+            if (!options.valueConverter) {
+                options.valueConverter = valueConverter;
+            }
+            else if (!options.valueConverter.fieldTypeInDb) {
+                //@ts-ignore
+                options.valueConverter.fieldTypeInDb = valueConverter.fieldTypeInDb;
+            }
+        });
+    }
     static string(...options) {
         return Field(() => String, ...options);
     }
@@ -186,7 +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);
+                r.validate = addValidator(r.validate, Validators.required, true);
             }
             if (r.maxLength) {
                 r.validate = addValidator(r.validate, Validators.maxLength(r.maxLength));
@@ -240,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

@@ -14,6 +14,8 @@ import { RelationLoader } from './relation-loader.js';
 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())
@@ -1961,6 +1963,7 @@ export function ValueListFieldType(...options) {
             ;
             (o.valueConverter = ValueListInfo.get(type)),
                 (o.displayValue = (item, val) => val?.caption);
+            o.validate = (entity, ref) => Validators.in(ValueListInfo.get(type).getValues())(entity, ref);
         }, ...options)(type, context);
     };
 }
@@ -2072,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;
@@ -2082,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,46 +1,25 @@
 export {};
-//p1 - should the remult api be deleteMany({id:[1,2]}) or deleteMany({where:{id:[1,2]}})
-//p1 - document cuid entity, usage of https://www.npmjs.com/package/@paralleldrive/cuid2
-//p1 - example of creating your own id column
-//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
-//y1 - consider replacing all errors with error classes that extend the base Error class
+//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 - Make async hooks gracefully handle non async hooks environment
+//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
+//p1 - article auth.js with express
 //p1 - document offline support
-//p1 - add section to Fields doc, explaining field type in db
-//p1 - add section about union type
-//p1 - add section about value list field type
+//y2 - should we validate relations
+//y1 - consider replacing all errors with error classes that extend the base Error class
+//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
+   - support returning redirect, and plain html (For sign in scenarios)
+
+ */
+//p1 - in this video I'll use remult to turn a frontend app to a fullstack app
 /*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)
 
 */
-/*y1 currency.ts:10 Uncaught TypeError: Currency_1 is not a constructor
-// - ValueListFieldType - the decorator gives an error in react vite project - see langulage yedidya
-// happens in target 2022, ts<5.1.6
-//typescript 5.1.6
-@ValueListFieldType()
-export class Currency {
-  constructor(
-    public id: number,
-    public caption: string,
-    public symbol: string
-  ) {}
-  static shekel = new Currency(1, 'Shekel', '₪');
-  static dollar = new Currency(2, 'Dollar', '$');
-  static euro = new Currency(3, 'Euro', '€');
-  static pound = new Currency(4, 'Pound', '£');
-  static yen = new Currency(5, 'Yen', '¥');
-}
-
-*/
-//y1 - allow api read to also support instance and filter. - problem with promise
-//y1 - admin url1 - pocketbase use /_ for the admin
 //y1 - consider sql expression gets a dbnames of it's own (that already has the "tableName" defined correctly) maybe also the filter translator
-/*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
-   - support returning redirect, and plain html (For sign in scenarios)
-
- */
 //y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
 //y1 - I think that the tests you've setup don't cover next app router - I added to the setup, but not sure where else
 //y1 - talk about the parameter issue with backend methods
@@ -55,8 +34,6 @@ export class Currency {
   })
   Description = ""*/
 //y2 - get backend methods to work when specifying types for date, and entities as poco's
-//y2 - conside law-q db based on schema issue - I think that while running the dataProvider function, we should have a valid remult - maybe even have a valid remult, that will be valid until api is run
-//y2 - #239 - (@JY) add a way to get from fieldMetadata back to entity repo (like we have in fieldRef)
 //y2 - constraints (@JY)
 /*p2 remult admin
 
@@ -71,11 +48,9 @@ export class Currency {
  - remult-admin didn't show a update for a table with a uniqua that is numeric
 */
 //remult
-//p1 - better support union types (status, etc... so it'll work also in filter etc...)
 //p1 - when a tasks table exists in a different schema - we get many errors
 //p1 - live query with include
 //p1 - adjust angular tutorial starter kit for latest angular (as is in tutorial)
-//p2 - allow find options preprocessor for api calls, to use for authorization
 //p2 - when subscribe is forbidden - the query still runs after the renew process
 //p2 - 'update tasks set  where id = $1
 //p2 - type metadata.key - to keyof entity - based on cwis input
@@ -83,23 +58,15 @@ export class Currency {
 //p2 - when value changes for field with error, clear error - so the user will feel comfortable
 //p2 - allowApiUpdate should be false for include in api false
 //docs
-//p2 - make sure that internal members do not appear in the documentation - try running it on the d.ts instead of the code itself.
 //------
 //y2 - from the crm-demo(https://crm-demo.up.railway.app/deals), after editing a deal: - _updateEntityBasedOnApi
 //y2 - Backend methods are transactions, it's not intuitive and maybe should be optional / opt in
 //y2 - how to run a transaction as a user
-//p2 - enum column
-//y2 - message for invalid value
 //y2 - message for relation that is missing
 //y2 - consider multi tenancies
-//p2 - more column types
-//p2 - document validators
 //p2 - and validators to reference
 //y2 - discuss a default date formatter
 //y2 - add some api testing framework for user unit tests (will help with codesandbox based discussions)
 //[ ] V2 - what to do about for relations count?
 //[ ] V2 - condition? not to fetch if null etc....
-//[ ] V3 - all these fields will also appear in the where etc... in the typescript api - but we will not enforce them
-//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
 //p1 - adjust react tutorial to esm

package/esm/src/validators.js

@@ -26,10 +26,9 @@ export class Validators {
     static regex = createValueValidatorWithArgs((val, regex) => regex.test(val));
     static email = createValueValidator((val) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val), 'Invalid Email');
     static url = createValueValidator((val) => !!new URL(val), 'Invalid Url');
-    static in = createValueValidatorWithArgs((val, values) => values.includes(val), (values) => `Value must be one of ${values.join(', ')}`);
+    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.7",
+    "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/column-interfaces.d.ts

@@ -247,17 +247,23 @@ export interface ValueConverter<valueType> {
      */
     displayValue?(val: valueType): string;
     /**
-     * Specifies the storage type used in the database for this field.
+     * Specifies the storage type used in the database for this field. This can be used to explicitly define the data type and precision of the field in the database.
      *
      * @example
-     * readonly fieldTypeInDb = 'decimal(18,2)';
+     * // Define a field with a specific decimal precision in the database
+     * @Fields.number({
+     *   valueConverter: {
+     *     fieldTypeInDb: 'decimal(18,8)'
+     *   }
+     * })
+     * price=0;
      */
     readonly fieldTypeInDb?: string;
     /**
      * Specifies the type of HTML input element suitable for values of valueType.
      *
      * @example
-     * readonly inputType = 'date';
+     * inputType = 'date';
      */
     readonly inputType?: string;
 }

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/isOfType.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cast = exports.isOfType = void 0;
 function isOfType(obj, checkMethod) {
-    return typeof obj[checkMethod] === 'function';
+    return typeof obj[checkMethod] !== 'undefined';
 }
 exports.isOfType = isOfType;
 function cast(obj, checkMethod) {

package/src/remult3/Fields.d.ts

@@ -16,7 +16,43 @@ export declare class Fields {
     static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
     static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
     static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    /**
+   * A CUID (Collision Resistant Unique Identifier) field.
+   * This id value is determined on the backend on insert, and can't be updated through the API.
+   * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+   */
     static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    /**
+   * Defines a field that can hold a value from a specified set of string literals.
+   * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
+   * @returns {ClassFieldDecorator<entityType, valueType | undefined>} - A class field decorator.
+   *
+   * @example
+   
+   * class MyEntity {
+   *   .@Fields.literal(() => ['open', 'closed', 'frozen', 'in progress'] as const)
+   *   status: 'open' | 'closed' | 'frozen' | 'in progress' = 'open';
+   * }
+   
+   *
+   * // This defines a field `status` in `MyEntity` that can only hold the values 'open', 'closed', 'frozen', or 'in progress'.
+   *
+   * @example
+   * // For better reusability and maintainability:
+   
+   * const statuses = ['open', 'closed', 'frozen', 'in progress'] as const;
+   * type StatusType = typeof statuses[number];
+   *
+   * class MyEntity {
+   *   .@Fields.literal(() => statuses)
+   *   status: StatusType = 'open';
+   * }
+   
+   *
+   * // This approach allows easy management and updates of the allowed values for the `status` field.
+   */
+    static literal<entityType = any, valueType extends string = any>(optionalValues: () => readonly valueType[], ...options: (StringFieldOptions<entityType, valueType> | ((options: StringFieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static enum<entityType = any, theEnum = any>(enumType: () => theEnum, ...options: (FieldOptions<entityType, theEnum[keyof theEnum]> | ((options: FieldOptions<entityType, theEnum[keyof theEnum]>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, theEnum[keyof theEnum] | undefined>;
     static string<entityType = any, valueType = string>(...options: (StringFieldOptions<entityType, valueType> | ((options: StringFieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
     static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
 }

package/src/remult3/Fields.js

@@ -9,6 +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 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() {
     }
@@ -63,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 () {
@@ -82,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 = [];
@@ -127,6 +134,11 @@ var Fields = /** @class */ (function () {
                 },
             }], tslib_1.__read(options), false));
     };
+    /**
+   * A CUID (Collision Resistant Unique Identifier) field.
+   * This id value is determined on the backend on insert, and can't be updated through the API.
+   * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+   */
     Fields.cuid = function () {
         var options = [];
         for (var _i = 0; _i < arguments.length; _i++) {
@@ -142,6 +154,71 @@ var Fields = /** @class */ (function () {
                 },
             }], tslib_1.__read(options), false));
     };
+    /**
+   * Defines a field that can hold a value from a specified set of string literals.
+   * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
+   * @returns {ClassFieldDecorator<entityType, valueType | undefined>} - A class field decorator.
+   *
+   * @example
+   
+   * class MyEntity {
+   *   .@Fields.literal(() => ['open', 'closed', 'frozen', 'in progress'] as const)
+   *   status: 'open' | 'closed' | 'frozen' | 'in progress' = 'open';
+   * }
+   
+   *
+   * // This defines a field `status` in `MyEntity` that can only hold the values 'open', 'closed', 'frozen', or 'in progress'.
+   *
+   * @example
+   * // For better reusability and maintainability:
+   
+   * const statuses = ['open', 'closed', 'frozen', 'in progress'] as const;
+   * type StatusType = typeof statuses[number];
+   *
+   * class MyEntity {
+   *   .@Fields.literal(() => statuses)
+   *   status: StatusType = 'open';
+   * }
+   
+   *
+   * // This approach allows easy management and updates of the allowed values for the `status` field.
+   */
+    Fields.literal = function (optionalValues) {
+        var options = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            options[_i - 1] = arguments[_i];
+        }
+        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 options = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            options[_i - 1] = arguments[_i];
+        }
+        var valueConverter;
+        return Field.apply(void 0, tslib_1.__spreadArray(tslib_1.__spreadArray([function () {
+                //@ts-ignore
+                return (enumType());
+            },
+            {
+                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 = 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) {
+                    options.valueConverter = valueConverter;
+                }
+                else if (!options.valueConverter.fieldTypeInDb) {
+                    //@ts-ignore
+                    options.valueConverter.fieldTypeInDb = valueConverter.fieldTypeInDb;
+                }
+            }], false));
+    };
     Fields.string = function () {
         var options = [];
         for (var _i = 0; _i < arguments.length; _i++) {
@@ -249,13 +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);
+                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();
@@ -305,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

@@ -18,6 +18,8 @@ var relation_loader_js_1 = require("./relation-loader.js");
 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())
@@ -3249,6 +3251,7 @@ function ValueListFieldType() {
                 ;
                 (o.valueConverter = ValueListInfo.get(type)),
                     (o.displayValue = function (item, val) { return val === null || val === void 0 ? void 0 : val.caption; });
+                o.validate = function (entity, ref) { return validators_js_1.Validators.in(ValueListInfo.get(type).getValues())(entity, ref); };
             }], tslib_1.__read(options), false))(type, context);
     };
 }
@@ -3377,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);
+                }
             }
         }
     }
@@ -3396,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

@@ -1,47 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//p1 - should the remult api be deleteMany({id:[1,2]}) or deleteMany({where:{id:[1,2]}})
-//p1 - document cuid entity, usage of https://www.npmjs.com/package/@paralleldrive/cuid2
-//p1 - example of creating your own id column
-//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
-//y1 - consider replacing all errors with error classes that extend the base Error class
+//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 - Make async hooks gracefully handle non async hooks environment
+//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
+//p1 - article auth.js with express
 //p1 - document offline support
-//p1 - add section to Fields doc, explaining field type in db
-//p1 - add section about union type
-//p1 - add section about value list field type
+//y2 - should we validate relations
+//y1 - consider replacing all errors with error classes that extend the base Error class
+//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
+   - support returning redirect, and plain html (For sign in scenarios)
+
+ */
+//p1 - in this video I'll use remult to turn a frontend app to a fullstack app
 /*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)
 
 */
-/*y1 currency.ts:10 Uncaught TypeError: Currency_1 is not a constructor
-// - ValueListFieldType - the decorator gives an error in react vite project - see langulage yedidya
-// happens in target 2022, ts<5.1.6
-//typescript 5.1.6
-@ValueListFieldType()
-export class Currency {
-  constructor(
-    public id: number,
-    public caption: string,
-    public symbol: string
-  ) {}
-  static shekel = new Currency(1, 'Shekel', '₪');
-  static dollar = new Currency(2, 'Dollar', '$');
-  static euro = new Currency(3, 'Euro', '€');
-  static pound = new Currency(4, 'Pound', '£');
-  static yen = new Currency(5, 'Yen', '¥');
-}
-
-*/
-//y1 - allow api read to also support instance and filter. - problem with promise
-//y1 - admin url1 - pocketbase use /_ for the admin
 //y1 - consider sql expression gets a dbnames of it's own (that already has the "tableName" defined correctly) maybe also the filter translator
-/*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
-   - support returning redirect, and plain html (For sign in scenarios)
-
- */
 //y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
 //y1 - I think that the tests you've setup don't cover next app router - I added to the setup, but not sure where else
 //y1 - talk about the parameter issue with backend methods
@@ -56,8 +35,6 @@ export class Currency {
   })
   Description = ""*/
 //y2 - get backend methods to work when specifying types for date, and entities as poco's
-//y2 - conside law-q db based on schema issue - I think that while running the dataProvider function, we should have a valid remult - maybe even have a valid remult, that will be valid until api is run
-//y2 - #239 - (@JY) add a way to get from fieldMetadata back to entity repo (like we have in fieldRef)
 //y2 - constraints (@JY)
 /*p2 remult admin
 
@@ -72,11 +49,9 @@ export class Currency {
  - remult-admin didn't show a update for a table with a uniqua that is numeric
 */
 //remult
-//p1 - better support union types (status, etc... so it'll work also in filter etc...)
 //p1 - when a tasks table exists in a different schema - we get many errors
 //p1 - live query with include
 //p1 - adjust angular tutorial starter kit for latest angular (as is in tutorial)
-//p2 - allow find options preprocessor for api calls, to use for authorization
 //p2 - when subscribe is forbidden - the query still runs after the renew process
 //p2 - 'update tasks set  where id = $1
 //p2 - type metadata.key - to keyof entity - based on cwis input
@@ -84,23 +59,15 @@ export class Currency {
 //p2 - when value changes for field with error, clear error - so the user will feel comfortable
 //p2 - allowApiUpdate should be false for include in api false
 //docs
-//p2 - make sure that internal members do not appear in the documentation - try running it on the d.ts instead of the code itself.
 //------
 //y2 - from the crm-demo(https://crm-demo.up.railway.app/deals), after editing a deal: - _updateEntityBasedOnApi
 //y2 - Backend methods are transactions, it's not intuitive and maybe should be optional / opt in
 //y2 - how to run a transaction as a user
-//p2 - enum column
-//y2 - message for invalid value
 //y2 - message for relation that is missing
 //y2 - consider multi tenancies
-//p2 - more column types
-//p2 - document validators
 //p2 - and validators to reference
 //y2 - discuss a default date formatter
 //y2 - add some api testing framework for user unit tests (will help with codesandbox based discussions)
 //[ ] V2 - what to do about for relations count?
 //[ ] V2 - condition? not to fetch if null etc....
-//[ ] V3 - all these fields will also appear in the where etc... in the typescript api - but we will not enforce them
-//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
 //p1 - adjust react tutorial to esm

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() {
@@ -48,11 +48,12 @@ var Validators = /** @class */ (function () {
     });
     Validators.email = createValueValidator(function (val) { return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val); }, 'Invalid Email');
     Validators.url = createValueValidator(function (val) { return !!new URL(val); }, 'Invalid Url');
-    Validators.in = createValueValidatorWithArgs(function (val, values) { return values.includes(val); }, function (values) { return "Value must be one of ".concat(values.join(', ')); });
+    Validators.in = createValueValidatorWithArgs(function (val, values) { return values.includes(val); }, function (values) { return "Value must be one of ".concat(values.map(function (y) {
+        return typeof y === "object" ? y['id'] !== undefined ? y['id'] : y.toString() : y;
+    }).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 () {
@@ -207,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;