remult 0.24.2-exp.0 → 0.25.0

package/esm/src/remult3/RepositoryImplementation.js

@@ -619,9 +619,11 @@ export class RepositoryImplementation {
         for (const col of this.fieldsOf(json)) {
             let ei = getEntitySettings(col.valueType, false);
             if (ei) {
-                result[col.key] = this.remult
-                    .repo(col.valueType)
-                    .fromJson(json[col.key]);
+                let val = json[col.key];
+                if (typeof val === 'string' || typeof val === 'number')
+                    result[col.key] = val;
+                else
+                    result[col.key] = this.remult.repo(col.valueType).fromJson(val);
             }
             else {
                 if (json[col.key] !== undefined) {
@@ -650,6 +652,8 @@ export class RepositoryImplementation {
     async findOne(options, skipOrderByAndLimit = false) {
         let r;
         let cacheInfo;
+        if (!options)
+            options = {};
         if (options.useCache) {
             let f = findOptionsToJson(options, this.metadata);
             let key = JSON.stringify(f);
@@ -816,7 +820,7 @@ export function createOldEntity(entity, remult) {
     return new EntityFullInfo(prepareColumnInfo(r, remult), info, remult, entity, key);
 }
 class rowHelperBase {
-    columnsInfo;
+    fieldsMetadata;
     instance;
     remult;
     isNewRow;
@@ -829,8 +833,8 @@ class rowHelperBase {
         this._error = val;
         this._subscribers?.reportChanged();
     }
-    constructor(columnsInfo, instance, remult, isNewRow) {
-        this.columnsInfo = columnsInfo;
+    constructor(fieldsMetadata, instance, remult, isNewRow) {
+        this.fieldsMetadata = fieldsMetadata;
         this.instance = instance;
         this.remult = remult;
         this.isNewRow = isNewRow;
@@ -840,10 +844,10 @@ class rowHelperBase {
                 remult = fac.remultFactory();
             }
         }
-        for (const col of columnsInfo) {
+        for (const col of fieldsMetadata) {
             let ei = getEntitySettings(col.valueType, false);
             if (ei && remult) {
-                let lookup = new LookupColumn(remult.repo(col.valueType), Boolean(col?.[relationInfoMember]), col.allowNull);
+                let lookup = new LookupColumn(remult.repo(col.valueType), Boolean(getRelationInfo(col.options)), col.allowNull);
                 this.lookups.set(col.key, lookup);
                 let val = instance[col.key];
                 let refImpl;
@@ -876,7 +880,7 @@ class rowHelperBase {
                 });
                 lookup.set(val);
             }
-            else if (getRelationInfo(col)?.type === 'toOne') {
+            else if (getRelationInfo(col.options)?.type === 'toOne') {
                 let hasVal = instance.hasOwnProperty(col.key);
                 let val = instance[col.key];
                 if (isNewRow && !val)
@@ -889,10 +893,10 @@ class rowHelperBase {
                         val = newVal;
                         if (newVal === undefined)
                             return;
-                        const op = col;
+                        const op = col.options;
                         if (op.field) {
                             this.instance[op.field] = this.remult
-                                .repo(getRelationInfo(col).toType())
+                                .repo(getRelationInfo(col.options).toType())
                                 .metadata.idMetadata.getId(newVal);
                         }
                         if (op.fields) {
@@ -920,7 +924,7 @@ class rowHelperBase {
     initSubscribers() {
         if (!this._subscribers) {
             this._subscribers = new SubscribableImp();
-            for (const col of this.columnsInfo) {
+            for (const col of this.fieldsMetadata) {
                 let ei = getEntitySettings(col.valueType, false);
                 let refImpl = this.fields.find(col.key);
                 refImpl._subscribers = new SubscribableImp();
@@ -968,7 +972,7 @@ class rowHelperBase {
             message: this.error,
         };
         if (!error.message) {
-            for (const col of this.columnsInfo) {
+            for (const col of this.fieldsMetadata) {
                 if (this.errors[col.key]) {
                     error.message =
                         this.fields[col.key].metadata.caption + ': ' + this.errors[col.key];
@@ -1021,10 +1025,10 @@ class rowHelperBase {
     }
     copyDataToObject(isNew = false) {
         let d = {};
-        for (const col of this.columnsInfo) {
+        for (const col of this.fieldsMetadata) {
             let lu = this.lookups.get(col.key);
             let val = undefined;
-            const rel = getRelationInfo(col);
+            const rel = getRelationInfo(col.options);
             if (lu)
                 val = lu.id;
             else
@@ -1077,11 +1081,8 @@ class rowHelperBase {
     async __performColumnAndEntityValidations() { }
     toApiJson(includeRelatedEntities = false, notJustApi = false) {
         let result = {};
-        for (const col of this.columnsInfo) {
-            if (notJustApi ||
-                !this.remult ||
-                col.includeInApi === undefined ||
-                this.remult.isAllowedForInstance(this.instance, col.includeInApi)) {
+        for (const col of this.fieldsMetadata) {
+            if (notJustApi || !this.remult || col.includedInApi(this.instance)) {
                 let val;
                 let lu = this.lookups.get(col.key);
                 let disable = false;
@@ -1094,7 +1095,7 @@ class rowHelperBase {
                     else
                         val = lu.id;
                 else {
-                    if (getRelationInfo(col) && !includeRelatedEntities) {
+                    if (getRelationInfo(col.options) && !includeRelatedEntities) {
                         disable = true;
                     }
                     else {
@@ -1117,14 +1118,12 @@ class rowHelperBase {
     }
     async _updateEntityBasedOnApi(body, ignoreApiAllowed = false) {
         let keys = Object.keys(body);
-        for (const col of this.columnsInfo) {
+        for (const col of this.fieldsMetadata) {
             if (keys.includes(col.key))
-                if (col.includeInApi === undefined ||
-                    this.remult.isAllowedForInstance(this.instance, col.includeInApi)) {
+                if (col.includedInApi(this.instance)) {
                     if (!this.remult ||
                         ignoreApiAllowed ||
-                        col.allowApiUpdate === undefined ||
-                        this.remult.isAllowedForInstance(this.instance, col.allowApiUpdate)) {
+                        col.apiUpdateAllowed(this.instance)) {
                         let lu = this.lookups.get(col.key);
                         if (lu)
                             lu.id = body[col.key];
@@ -1142,20 +1141,20 @@ export class rowHelperImplementation extends rowHelperBase {
     edp;
     _isNew;
     constructor(info, instance, repository, edp, remult, _isNew) {
-        super(info.columnsInfo, instance, remult, _isNew);
+        super(info.fieldsMetadata, instance, remult, _isNew);
         this.info = info;
         this.repository = repository;
         this.edp = edp;
         this._isNew = _isNew;
         this.metadata = info;
         if (_isNew) {
-            for (const col of info.columnsInfo) {
-                if (col.defaultValue && instance[col.key] === undefined) {
-                    if (typeof col.defaultValue === 'function') {
-                        instance[col.key] = col.defaultValue(instance);
+            for (const col of info.fieldsMetadata) {
+                if (col.options.defaultValue && instance[col.key] === undefined) {
+                    if (typeof col.options.defaultValue === 'function') {
+                        instance[col.key] = col.options.defaultValue(instance);
                     }
                     else if (!instance[col.key])
-                        instance[col.key] = col.defaultValue;
+                        instance[col.key] = col.options.defaultValue;
                 }
             }
         }
@@ -1221,8 +1220,8 @@ export class rowHelperImplementation extends rowHelperBase {
                 [Symbol.iterator]: () => _items[Symbol.iterator](),
                 toArray: () => _items,
             };
-            for (const c of this.info.columnsInfo) {
-                _items.push((r[c.key] = new FieldRefImplementation(c, this.info.fields[c.key], this.instance, this, this)));
+            for (const c of this.info.fieldsMetadata) {
+                _items.push((r[c.key] = new FieldRefImplementation(c.options, c, this.instance, this, this)));
             }
             this._columns = r;
         }
@@ -1389,9 +1388,9 @@ export class rowHelperImplementation extends rowHelperBase {
     async calcServerExpression() {
         if (isBackend())
             //y2 should be changed to be based on data provider - consider naming
-            for (const col of this.info.columnsInfo) {
-                if (col.serverExpression) {
-                    this.instance[col.key] = await col.serverExpression(this.instance);
+            for (const col of this.info.fieldsMetadata) {
+                if (col.options.serverExpression) {
+                    this.instance[col.key] = await col.options.serverExpression(this.instance);
                 }
             }
     }
@@ -1410,9 +1409,9 @@ export class rowHelperImplementation extends rowHelperBase {
         return false;
     }
     async __performColumnAndEntityValidations() {
-        for (const c of this.columnsInfo) {
-            if (c.validate) {
-                let col = new FieldRefImplementation(c, this.info.fields[c.key], this.instance, this, this);
+        for (const c of this.fieldsMetadata) {
+            if (c.options.validate) {
+                let col = new FieldRefImplementation(c.options, c, this.instance, this, this);
                 await col.__performValidation();
             }
         }
@@ -1426,7 +1425,7 @@ export class rowHelperImplementation extends rowHelperBase {
             }
     }
 }
-const controllerColumns = Symbol('controllerColumns');
+const controllerColumns = Symbol.for('controllerColumns');
 function prepareColumnInfo(r, remult) {
     return r.map((x) => decorateColumnSettings(x.settings(remult), remult));
 }
@@ -1450,7 +1449,7 @@ export function getControllerRef(container, remultArg) {
             }
             base = Object.getPrototypeOf(base);
         }
-        container[controllerColumns] = result = new controllerRefImpl(prepareColumnInfo(columnSettings, remultVar), container, remultVar);
+        container[controllerColumns] = result = new controllerRefImpl(prepareColumnInfo(columnSettings, remultVar).map((x) => new columnDefsImpl(x, undefined, remultVar)), container, remultVar);
     }
     return result;
 }
@@ -1464,7 +1463,7 @@ export class controllerRefImpl extends rowHelperBase {
             toArray: () => _items,
         };
         for (const col of columnsInfo) {
-            _items.push((r[col.key] = new FieldRefImplementation(col, new columnDefsImpl(col, undefined, remult), instance, undefined, this)));
+            _items.push((r[col.key] = new FieldRefImplementation(col.options, col, instance, undefined, this)));
         }
         this.fields = r;
     }
@@ -1525,6 +1524,8 @@ export class FieldRefImplementation {
                     .relations(this.container)[this.metadata.key].findOne();
                 if (val)
                     this.container[this.metadata.key] = val;
+                else
+                    return null;
             }
         }
         else if (lu) {
@@ -1620,14 +1621,42 @@ export class FieldRefImplementation {
     entityRef;
     async __performValidation() {
         try {
-            let x = typeof this.settings.validate;
-            if (Array.isArray(this.settings.validate)) {
-                for (const v of this.settings.validate) {
-                    await v(this.container, this);
+            const processValidation = (result) => {
+                if (result !== true && result !== undefined && !this.error) {
+                    if (typeof result === 'string' && result.length > 0)
+                        this.error = result;
+                    else
+                        this.error = 'invalid value';
                 }
+            };
+            if (this.settings.validate) {
+                let self = this;
+                let event = {
+                    entityRef: this.entityRef,
+                    get error() {
+                        return self.error;
+                    },
+                    set error(value) {
+                        self.error = value;
+                    },
+                    isNew: self.rowBase.isNewRow,
+                    load: () => self.load(),
+                    metadata: self.metadata,
+                    originalValue: self.originalValue,
+                    value: self.value,
+                    valueChanged: () => self.valueChanged(),
+                    originalValueIsNull: () => self.originalValueIsNull(),
+                    valueIsNull: () => self.valueIsNull(),
+                    isBackend: () => !self.rowBase?.remult?.dataProvider?.isProxy,
+                };
+                if (Array.isArray(this.settings.validate)) {
+                    for (const v of this.settings.validate) {
+                        processValidation(await v(this.container, event));
+                    }
+                }
+                else if (typeof this.settings.validate === 'function')
+                    processValidation(await this.settings.validate(this.container, event));
             }
-            else if (typeof this.settings.validate === 'function')
-                await this.settings.validate(this.container, this);
         }
         catch (error) {
             if (typeof error === 'string')
@@ -1698,7 +1727,28 @@ export class columnDefsImpl {
         this.remult = remult;
         this.options = this.settings;
         this.target = this.settings.target;
-        this.valueConverter = this.settings.valueConverter;
+        this.valueConverter = new Proxy(this.settings.valueConverter, {
+            get: (target, prop) => {
+                let result = target[prop];
+                if (typeof result === 'function') {
+                    return (...args) => {
+                        try {
+                            return target[prop](...args);
+                        }
+                        catch (err) {
+                            const error = `${String(prop)} failed for value ${args?.[0]}. Error: ${typeof err === 'string' ? err : err.message}`;
+                            throw {
+                                message: this.caption + ': ' + error,
+                                modelState: {
+                                    [this.key]: error,
+                                },
+                            };
+                        }
+                    };
+                }
+                return result;
+            },
+        });
         this.allowNull = !!this.settings.allowNull;
         this.valueType = this.settings.valueType;
         this.key = this.settings.key;
@@ -1754,14 +1804,13 @@ export class columnDefsImpl {
     valueType;
 }
 class EntityFullInfo {
-    columnsInfo;
     entityInfo;
     remult;
     entityType;
     key;
     options;
+    fieldsMetadata = [];
     constructor(columnsInfo, entityInfo, remult, entityType, key) {
-        this.columnsInfo = columnsInfo;
         this.entityInfo = entityInfo;
         this.remult = remult;
         this.entityType = entityType;
@@ -1788,14 +1837,14 @@ class EntityFullInfo {
             this.key = entityType.name;
         if (!entityInfo.dbName)
             entityInfo.dbName = this.key;
-        let _items = [];
+        this.dbName = entityInfo.dbName;
         let r = {
             find: (c) => r[typeof c === 'string' ? c : c.key],
-            [Symbol.iterator]: () => _items[Symbol.iterator](),
-            toArray: () => _items,
+            [Symbol.iterator]: () => this.fieldsMetadata[Symbol.iterator](),
+            toArray: () => this.fieldsMetadata,
         };
         for (const x of columnsInfo) {
-            _items.push((r[x.key] = new columnDefsImpl(x, this, remult)));
+            this.fieldsMetadata.push((r[x.key] = new columnDefsImpl(x, this, remult)));
         }
         this.fields = r;
         this.caption = buildCaption(entityInfo.caption, this.key, remult, this);
@@ -1903,7 +1952,7 @@ export function FieldType(...options) {
             options = [];
         }
         options.splice(0, 0, { valueType: target });
-        Reflect.defineMetadata(storableMember, options, target);
+        target[storableMember] = options;
         return target;
     };
 }
@@ -1950,7 +1999,7 @@ export class ValueListInfo {
         if (this.isNumeric) {
             this.fieldTypeInDb = 'integer';
         }
-        var options = Reflect.getMetadata(storableMember, this.valueListType);
+        var options = this.valueListType[storableMember];
         if (options) {
             for (const op of options) {
                 if (op?.getValues) {
@@ -2020,7 +2069,7 @@ export function getValueList(type) {
     }
     return ValueListInfo.get(type).getValues();
 }
-export const storableMember = Symbol('storableMember');
+export const storableMember = Symbol.for('storableMember');
 export function buildOptions(options, remult) {
     let r = {};
     for (const o of options) {
@@ -2035,7 +2084,7 @@ export function buildOptions(options, remult) {
 }
 export function decorateColumnSettings(settings, remult) {
     if (settings.valueType) {
-        let settingsOnTypeLevel = Reflect.getMetadata(storableMember, settings.valueType);
+        let settingsOnTypeLevel = settings.valueType[storableMember];
         if (settingsOnTypeLevel) {
             settings = {
                 ...buildOptions(settingsOnTypeLevel, remult),

package/esm/src/remult3/entity.js

@@ -62,8 +62,8 @@ export function Entity(key, ...options) {
         };
         allEntities.push(target);
         setControllerSettings(target, { key });
-        Reflect.defineMetadata(entityInfo, factory, target);
-        Reflect.defineMetadata(entityInfo_key, key, target);
+        target[entityInfo] = factory;
+        target[entityInfo_key] = key;
         return target;
     };
 }

package/esm/src/remult3/getEntityRef.js

@@ -6,9 +6,9 @@ export function getEntityRef(entity, throwException = true) {
             ' was not initialized using a context');
     return x;
 }
-export const entityMember = Symbol('entityMember');
-export const entityInfo = Symbol('entityInfo');
-export const entityInfo_key = Symbol('entityInfo_key');
+export const entityMember = Symbol.for('entityMember');
+export const entityInfo = Symbol.for('entityInfo');
+export const entityInfo_key = Symbol.for('entityInfo_key');
 export function getEntitySettings(entity, throwError = true) {
     if (entity === undefined)
         if (throwError) {
@@ -16,12 +16,12 @@ export function getEntitySettings(entity, throwError = true) {
         }
         else
             return undefined;
-    let info = Reflect.getMetadata(entityInfo, entity);
+    let info = entity[entityInfo];
     if (!info && throwError)
         throw new Error(entity.prototype.constructor.name +
             " is not a known entity, did you forget to set @Entity() or did you forget to add the '@' before the call to Entity?");
     return info;
 }
 export function getEntityKey(entity) {
-    return Reflect.getMetadata(entityInfo_key, entity);
+    return entity[entityInfo_key];
 }

package/esm/src/remult3/relationInfoMember.js

@@ -1,4 +1,4 @@
-export const relationInfoMember = Symbol('relationInfo');
+export const relationInfoMember = Symbol.for('relationInfo');
 export function getRelationInfo(options) {
     return options?.[relationInfoMember];
 }

package/esm/src/remult3/remult3.js

@@ -1,12 +1,7 @@
 export {};
-/*y1 - investigated sqlite in web, the chrome recommendation seemed hardly used -
-- https://developer.chrome.com/blog/sqlite-wasm-in-the-browser-backed-by-the-origin-private-file-system/
-- https://www.npmjs.com/package/@sqlite.org/sqlite-wasm
- All I could find is correspondance around evolu :) the guy I met in prague last year
- Indexed db was also annoying with it's upgrade process etc...
- I'm OPFS & json for now.
+//y1 - discuss limit and include queries
+//y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
 //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
 //p1 - enum column
@@ -48,6 +43,8 @@ remult.apiClient.url='localhost:3007/api
 
 
 */
+//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)
 //y2 - live query refresh of view on table update
@@ -71,3 +68,5 @@ remult.apiClient.url='localhost:3007/api
 //[ ] 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

package/esm/src/server-action-info.js

@@ -9,4 +9,4 @@ export const actionInfo = {
         close: () => { },
     }),
 };
-export const serverActionField = Symbol('serverActionField');
+export const serverActionField = Symbol.for('serverActionField');

package/esm/src/server-action.js

@@ -395,4 +395,4 @@ export async function prepareReceivedArgs(types, args, remult, ds, res) {
         }
     return args;
 }
-export const classBackendMethodsArray = Symbol('classBackendMethodsArray');
+export const classBackendMethodsArray = Symbol.for('classBackendMethodsArray');

package/esm/src/validators.js

@@ -1,36 +1,128 @@
-import { isBackend } from './context.js';
 export class Validators {
-    static required = Object.assign((entity, col, message = undefined) => {
-        if (!col.value ||
-            (typeof col.value === 'string' && col.value.trim().length == 0))
-            col.error = message || Validators.required.defaultMessage;
-    }, {
-        withMessage: (message) => {
-            return (entity, col) => Validators.required(entity, col, message);
-        },
-        defaultMessage: 'Should not be empty',
-    });
-    static unique = Object.assign(async (entity, col, message = undefined) => {
-        if (!col.entityRef)
+    static required = createValidator(async (_, e) => e.value != null && e.value != undefined && e.value !== '' && e.value != 0, 'Should not be empty');
+    static unique = createValidator(async (_, e) => {
+        if (!e.entityRef)
             throw 'unique validation may only work on columns that are attached to an entity';
-        if (col.entityRef.isNew() || col.valueChanged()) {
-            if (await col.entityRef.repository.count({
-                [col.metadata.key]: col.value,
-            }))
-                col.error = message || Validators.unique.defaultMessage;
+        if (e.isBackend() && (e.isNew || e.valueChanged())) {
+            return ((await e.entityRef.repository.count({
+                [e.metadata.key]: e.value,
+            })) == 0);
         }
-    }, {
-        withMessage: (message) => {
-            return (entity, col) => Validators.unique(entity, col, message);
+        else
+            return true;
+    }, 'already exists');
+    /**
+     * @deprecated is `unique` instead - it also runs only on the backend
+     */
+    static uniqueOnBackend = createValidator(async (_, e) => {
+        if (e.isBackend() && (e.isNew || e.valueChanged())) {
+            return ((await e.entityRef.repository.count({
+                [e.metadata.key]: e.value,
+            })) == 0);
+        }
+        else
+            return true;
+    }, Validators.unique.defaultMessage);
+    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 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')
+        .join(', ')}`);
+    static relationExists = createValidator(async (_, e) => {
+        if (e.valueIsNull())
+            return true;
+        if (!e.isBackend())
+            return true;
+        return Boolean(await e.load());
+    }, 'Relation value does not exist');
+    static maxLength = createValueValidatorWithArgs((val, maxLength) => val.length <= maxLength, (maxLength) => `Value must be at most ${maxLength} characters`);
+    static defaultMessage = 'Invalid value';
+}
+export function createValidator(validate, defaultMessage) {
+    const validation = async (entity, e, message) => {
+        const valid = await validate(entity, e);
+        if (typeof valid === 'string' && valid.length > 0)
+            e.error = valid;
+        else if (!valid)
+            e.error =
+                (typeof message === 'function' && message(entity, e, undefined)) ||
+                    message ||
+                    (typeof defaultMessage === 'function' &&
+                        defaultMessage(entity, e, undefined)) ||
+                    defaultMessage ||
+                    Validators.defaultMessage;
+    };
+    const result = (entityOrMessage, e, message) => {
+        if (typeof entityOrMessage === 'string' ||
+            entityOrMessage === 'function' ||
+            (entityOrMessage === undefined && e === undefined)) {
+            return async (entity, e, message) => await validation(entity, e, entityOrMessage || message);
+        }
+        return validation(entityOrMessage, e, message);
+    };
+    //@ts-ignore
+    return Object.assign(result, {
+        withMessage: (message) => async (entity, e) => result(entity, e, message),
+        get defaultMessage() {
+            return defaultMessage;
+        },
+        set defaultMessage(val) {
+            defaultMessage = val;
+        },
+        isValid: validate,
+    });
+}
+export function valueValidator(validate, defaultMessage) {
+    return (entity, e) => validate(e.value) || defaultMessage || false;
+}
+export function createValueValidator(validate, defaultMessage) {
+    return createValidator((_, e) => {
+        if (e.value === undefined || e.value === null)
+            return true;
+        return validate(e.value);
+    }, defaultMessage);
+}
+export function createValueValidatorWithArgs(validate, defaultMessage) {
+    const result = createValidatorWithArgs((_, e, args) => {
+        if (e.value === undefined || e.value === null)
+            return true;
+        return validate(e.value, args);
+    }, (_, e, args) => (typeof defaultMessage === 'function' && defaultMessage(args)) ||
+        defaultMessage);
+    return Object.assign((entity, e) => result(entity, e), {
+        get defaultMessage() {
+            return defaultMessage;
+        },
+        set defaultMessage(val) {
+            defaultMessage = val;
         },
-        defaultMessage: 'already exists',
     });
-    static uniqueOnBackend = Object.assign(async (entity, col, message = undefined) => {
-        if (isBackend())
-            return Validators.unique(entity, col, message);
-    }, {
-        withMessage: (message) => {
-            return (entity, col) => Validators.uniqueOnBackend(entity, col, message);
+}
+export function createValidatorWithArgs(validate, defaultMessage) {
+    const result = (args, message) => async (entity, e) => {
+        const valid = await validate(entity, e, args);
+        if (typeof valid === 'string')
+            e.error = valid;
+        else if (!valid)
+            e.error =
+                message || defaultMessage
+                    ? typeof defaultMessage === 'function'
+                        ? defaultMessage(entity, e, args)
+                        : defaultMessage
+                    : Validators.defaultMessage;
+    };
+    return Object.assign(result, {
+        get defaultMessage() {
+            return defaultMessage;
+        },
+        set defaultMessage(val) {
+            defaultMessage = val;
         },
     });
 }
+//y1 - talk about the 3rd parameter as message
+//y1 - talk about the changed signature breaking existing validations and preventing the usage of unique outside the normal flow
+//y1 - talk about the defaultMessage value now being a function that get's too many arguments, that makes it's reuse that much harder