@palmares/schemas 0.0.1 → 0.1.0

package/dist/cjs/types/validators/utils.d.ts

@@ -3,24 +3,30 @@ import type { ErrorCodes } from '../adapter/types';
 import type Schema from '../schema/schema';
 import type { ValidationFallbackCallbackReturnType, ValidationFallbackCallbackType, ValidationFallbackReturnType } from '../schema/types';
 /**
- * Okay, so what is this? This is a validator class, it represents a Node on a linked list. The linked list has lower priority validators on the end of the list and higher
- * priority validators on the start of the list. Maybe in the future we can change that to a binary tree, but for now this is enough.
+ * Okay, so what is this? This is a validator class, it represents a Node on a linked list. The linked list
+ * has lower priority validators on the end of the list and higher priority validators on the start of the
+ * list. Maybe in the future we can change that to a binary tree, but for now this is enough.
  *
- * Why did we choose this approach? Because what i was doing was that i saw myself repeating the same code 3 times on the schema in order to make the validation work. Each validator had
- * a different return type, i didn't like that. I wanted to add more power and control on the validator, not on the schema. So i created this class. So pretty much, over here and
- * on each validator we can define the type it is. It can actually be three: `low`, `medium` and `high`. The `low` validators are the ones that are going to be executed last, the `high` validators
- * are the ones that are going to be executed first. High validators validate if the value is null or undefined, if it allows that. It can stop the execution of the other validators if it wants to.
+ * Why did we choose this approach? Because what i was doing was that i saw myself repeating the same code 3
+ * times on the schema in order to make the validation work. Each validator had  a different return type, i
+ * didn't like that. I wanted to add more power and control on the validator, not on the schema. So i created
+ * this class. So pretty much, over here and on each validator we can define the type it is. It can actually
+ * be three: `low`, `medium` and `high`. The `low` validators are the ones that are going to be executed last,
+ * The `high` validators are the ones that are going to be executed first. High validators validate if the value
+ * is null or undefined, if it allows that. It can stop the execution of the other validators if it wants to.
  *
- * Example: Let's say that the value is null, if the value is null, is there a reason to check if it's a number? No, right? So the high validator can stop the execution of the other validators.
- * Same as before, if the value is not a number, is there a reason to check if it's value is greater than the `max` allowed 10? No, right? So the medium validator can stop the execution of
- * the other validators.
+ * Example: Let's say that the value is null, if the value is null, is there a reason to check if it's a number?
+ * No, right? So the high validator can stop the execution of the other validators.
+ * Same as before, if the value is not a number, is there a reason to check if it's value is greater than the
+ * `max` allowed 10? No, right? So the medium validator can stop the execution of the other validators.
  *
- * That's what this solve, it's a better approach than repeating the same code 3 times on the schema. It's also more powerful, because if we need to add any extra priorities we can do that easily
- * without changing the schema.
+ * That's what this solve, it's a better approach than repeating the same code 3 times on the schema. It's also
+ * more powerful, because if we need to add any extra priorities we can do that easily without changing the schema.
  */
 export default class Validator {
     child?: Validator;
     parent?: Validator;
+    fallbackNamesAdded: Set<unknown>;
     priority: number;
     fallbacks: ((value: any, path: (string | number)[], options: Parameters<Schema['__transformToAdapter']>[0]) => Promise<{
         parsed: any;
@@ -34,15 +40,21 @@ export default class Validator {
     }>)[];
     constructor(type: ValidatorTypes);
     /**
-     * We create all of the validators on the schema in order, i actually didn't want to go on that route but i found it easier to do so.
+     * We create all of the validators on the schema in order, i actually didn't want to go on that route but i
+     * found it easier to do so.
      *
-     * The logic here is simple, if it's not the same priority we will walk on the linked list until we find a validator that matches the priority we are expecting. If we can't walk anymore, we create
-     * the next priority validator and append it to the linked list. Be aware that it's a double linked list, so we can walk both ways, from the end to the start and from the start to the end.
-     * So you don't really need to start from the root, the linked list can start from anywhere and it will find it's way through.
+     * The logic here is simple, if it's not the same priority we will walk on the linked list until we find
+     * a validator that matches the priority we are expecting. If we can't walk anymore, we create the next
+     * priority validator and append it to the linked list. Be aware that it's a double linked list, so we
+     * can walk both ways, from the end to the start and from the start to the end.
+     * So you don't really need to start from the root, the linked list can start from anywhere and it will
+     * find it's way through.
      *
-     * I know there are better ways to do this instead of walking through the linked list, but like i explained before, this is enough for now.
+     * I know there are better ways to do this instead of walking through the linked list, but like i explained
+     * before, this is enough for now.
      *
-     * If the priority is higher than the current priority saved on the schema, we should substitute the rootValidator on the schema with the new one.
+     * If the priority is higher than the current priority saved on the schema, we should substitute the
+     * rootValidator on the schema with the new one.
      *
      * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema.
      * @param type - The type of the fallback that we are adding.
@@ -51,12 +63,14 @@ export default class Validator {
      * @param options - The options that we are passing to the fallback.
      */
     private checkAppendOrCreate;
-    addFallback(schema: Schema, type: ValidatorTypes, fallback: ValidationFallbackCallbackType, options?: Parameters<(typeof Validator)['createAndAppendFallback']>[2]): void;
+    addFallback(schema: Schema, type: ValidatorTypes, fallbackName: string, fallback: ValidationFallbackCallbackType, options?: Parameters<(typeof Validator)['createAndAppendFallback']>[2]): void;
     /**
-     * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest priority to the lowest priority.
-     * A validator can stop the execution of the other validators if it feels like so. Like on the example of a value being null or undefined.
+     * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest
+     * priority to the lowest priority. A validator can stop the execution of the other validators if it feels
+     * like so. Like on the example of a value being null or undefined.
      *
-     * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is used to avoid duplicated errors.
+     * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is
+     * used to avoid duplicated errors.
      * @param path - The path that we are validating right now.
      * @param parseResult - The result of the parsing, it contains the parsed value and the errors that we found.
      * @param options - The options that we are passing to the fallback.
@@ -66,13 +80,16 @@ export default class Validator {
         parsed: any;
     }, options: Parameters<Schema['__transformToAdapter']>[0]): Promise<ValidationFallbackCallbackReturnType>;
     /**
-     * This static method takes care of everything for you. This means that you should only call this method for appending new fallbacks, it takes care of creating the root validator
-     * and making sure that the rootValidator on the schema is the highest priority one.
+     * This static method takes care of everything for you. This means that you should only call this method
+     * for appending new fallbacks, it takes care of creating the root validator and making sure that the
+     * rootValidator on the schema is the highest priority one.
      *
-     * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema. We automatically define the rootValidator on the schema
-     * so you don't need to worry about that.
-     * @param fallback - The fallback that we are adding. This is an object that contains the type of the fallback and the callback that we are adding.
-     * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent` are passed to the `addFallback` method.
+     * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific
+     * schema. We automatically define the rootValidator on the schema so you don't need to worry about that.
+     * @param fallback - The fallback that we are adding. This is an object that contains the type of the
+     * fallback and the callback that we are adding.
+     * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent`
+     * are passed to the `addFallback` method.
      */
     static createAndAppendFallback(schema: Schema<any, any>, fallback: ValidationFallbackReturnType, options?: {
         at?: number;

package/dist/cjs/types/validators/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/validators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,EACV,oCAAoC,EACpC,8BAA8B,EAC9B,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AAgBzB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,CAAC,CACV,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,KACnD,OAAO,CAAC;QACX,MAAM,EAAE,GAAG,CAAC;QACZ,MAAM,EAAE;YACN,OAAO,EAAE,OAAO,CAAC;YACjB,IAAI,EAAE,UAAU,CAAC;YACjB,OAAO,EAAE,MAAM,CAAC;YAChB,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;SAC3B,EAAE,CAAC;QACJ,sBAAsB,CAAC,EAAE,OAAO,CAAC;KAClC,CAAC,CAAC,EAAE,CAAM;gBAEC,IAAI,EAAE,cAAc;IAIhC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,mBAAmB;IA0B3B,WAAW,CACT,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,8BAA8B,EACxC,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;IAWxE;;;;;;;;OAQG;IACG,QAAQ,CACZ,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,EAC9B,IAAI,EAAE,oCAAoC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EACpE,WAAW,EAAE;QACX,MAAM,EAAE,SAAS,GAAG,oCAAoC,CAAC,QAAQ,CAAC,CAAC;QACnE,MAAM,EAAE,GAAG,CAAC;KACb,EACD,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,GACrD,OAAO,CAAC,oCAAoC,CAAC;IA4BhD;;;;;;;;OAQG;IACH,MAAM,CAAC,uBAAuB,CAC5B,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EACxB,QAAQ,EAAE,4BAA4B,EACtC,OAAO,CAAC,EAAE;QACR,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB;IAcH,QAAQ,CAAC,KAAK,SAAI,GAAG,MAAM;CAK5B"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/validators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,EACV,oCAAoC,EACpC,8BAA8B,EAC9B,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AAgBzB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,kBAAkB,eAAa;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,CAAC,CACV,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,KACnD,OAAO,CAAC;QACX,MAAM,EAAE,GAAG,CAAC;QACZ,MAAM,EAAE;YACN,OAAO,EAAE,OAAO,CAAC;YACjB,IAAI,EAAE,UAAU,CAAC;YACjB,OAAO,EAAE,MAAM,CAAC;YAChB,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;SAC3B,EAAE,CAAC;QACJ,sBAAsB,CAAC,EAAE,OAAO,CAAC;KAClC,CAAC,CAAC,EAAE,CAAM;gBAEC,IAAI,EAAE,cAAc;IAMhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CAAC,mBAAmB;IA2B3B,WAAW,CACT,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,cAAc,EACpB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,8BAA8B,EACxC,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;IAcxE;;;;;;;;;;OAUG;IACG,QAAQ,CACZ,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,EAC9B,IAAI,EAAE,oCAAoC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EACpE,WAAW,EAAE;QACX,MAAM,EAAE,SAAS,GAAG,oCAAoC,CAAC,QAAQ,CAAC,CAAC;QACnE,MAAM,EAAE,GAAG,CAAC;KACb,EACD,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,GACrD,OAAO,CAAC,oCAAoC,CAAC;IA6BhD;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,uBAAuB,CAC5B,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EACxB,QAAQ,EAAE,4BAA4B,EACtC,OAAO,CAAC,EAAE;QACR,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB;IAcH,QAAQ,CAAC,KAAK,SAAI,GAAG,MAAM;CAK5B"}

package/dist/esm/src/adapter/fields/index.js

@@ -15,7 +15,7 @@ export default class FieldAdapter {
             functionName: 'translate'
         });
     }
-    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+    parse(_adapter, _fieldAdapter, _schema, _value, _args) {
         throw new SchemaAdapterNotImplementedError({
             className: this.constructor.name,
             functionName: 'parse'
@@ -28,7 +28,7 @@ export default class FieldAdapter {
         });
     }
     // eslint-disable-next-line ts/require-await
-    async formatError(_adapter, _fieldAdapter, _error, _metadata) {
+    async formatError(_adapter, _fieldAdapter, _schema, _error, _metadata) {
         throw new SchemaAdapterNotImplementedError({
             className: this.constructor.name,
             functionName: 'formatError'

package/dist/esm/src/adapter/fields/object.js

@@ -17,4 +17,10 @@ export default class ObjectFieldAdapter extends FieldAdapter {
             functionName: 'parse'
         });
     }
+    toString(_adapter, _fieldAdapter, _args, _base) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'toString'
+        });
+    }
 }

package/dist/esm/src/adapter/index.js

@@ -8,6 +8,7 @@ export default class SchemaAdapter {
     array;
     boolean;
     datetime;
+    adapterInstance;
     // eslint-disable-next-line ts/require-await
     async formatError(_error, _metadata) {
         throw new SchemaAdapterNotImplementedError({

package/dist/esm/src/constants.js

@@ -1,5 +1,4 @@
 export const DEFAULT_NUMBER_MAX_EXCEPTION = (max, inclusive)=>`The number is greater than the allowed ${max}.${inclusive ? ` The value ${max} is accepted as well.` : ''}`;
 export const DEFAULT_NUMBER_MIN_EXCEPTION = (min, inclusive)=>`The number is less than the allowed ${min}.${inclusive ? ` The value ${min} is accepted as well.` : ''}`;
-export const DEFAULT_NUMBER_NEGATIVE_EXCEPTION = (allowZero)=>`The number should be negative.${allowZero ? ` The value 0 is accepted as well.` : ''}`;
 export const DEFAULT_NUMBER_POSITIVE_EXCEPTION = (allowZero)=>`The number should be positive.${allowZero ? ` The value 0 is accepted as well.` : ''}`;
-export const DEFAULT_NUMBER_INTEGER_EXCEPTION = ()=>`THe number should be an integer.`;
+export const DEFAULT_NUMBER_INTEGER_EXCEPTION = ()=>`The number should be an integer.`;

package/dist/esm/src/domain.js

@@ -1,2 +1,12 @@
 import { domain } from '@palmares/core';
-export default domain('@palmares/schemas', __dirname, {});
+import { getDefaultAdapter, setDefaultAdapter } from './conf';
+const schemasDomain = domain('@palmares/schemas', __dirname, {
+    commands: {},
+    // eslint-disable-next-line ts/require-await
+    load: async (settings)=>{
+        setDefaultAdapter(new settings.schemaAdapter());
+        const schemaAdapter = getDefaultAdapter();
+        return undefined;
+    }
+});
+export default schemasDomain;

package/dist/esm/src/index.js

@@ -1,4 +1,5 @@
 import SchemaAdapter from './adapter';
+import SchemaDomain from './domain';
 import { modelSchema } from './model';
 import ArraySchema, { array } from './schema/array';
 import BooleanSchema, { boolean } from './schema/boolean';
@@ -8,22 +9,23 @@ import ObjectSchema, { object } from './schema/object';
 import Schema, { schema } from './schema/schema';
 import StringSchema, { string } from './schema/string';
 import UnionSchema, { union } from './schema/union';
-export { default as default } from './domain';
-export { default as FieldAdapter } from './adapter/fields';
-export { default as NumberAdapter } from './adapter/fields/number';
-export { default as ObjectFieldAdapter } from './adapter/fields/object';
-export { default as UnionFieldAdapter } from './adapter/fields/union';
-export { default as StringFieldAdapter } from './adapter/fields/string';
-export { default as ArrayFieldAdapter } from './adapter/fields/array';
-export { default as BooleanFieldAdapter } from './adapter/fields/boolean';
-export { default as DatetimeFieldAdapter } from './adapter/fields/datetime';
-export { setDefaultAdapter } from './conf';
+export { default as FieldAdapter, fieldAdapter } from './adapter/fields';
+export { default as NumberFieldAdapter, numberFieldAdapter } from './adapter/fields/number';
+export { default as ObjectFieldAdapter, objectFieldAdapter } from './adapter/fields/object';
+export { default as UnionFieldAdapter, unionFieldAdapter } from './adapter/fields/union';
+export { default as StringFieldAdapter, stringFieldAdapter } from './adapter/fields/string';
+export { default as ArrayFieldAdapter, arrayFieldAdapter } from './adapter/fields/array';
+export { default as BooleanFieldAdapter, booleanFieldAdapter } from './adapter/fields/boolean';
+export { default as DatetimeFieldAdapter, datetimeFieldAdapter } from './adapter/fields/datetime';
+export { Infer as infer } from './types';
+export { setDefaultAdapter, getDefaultAdapter } from './conf';
 export * from './adapter/types';
 export * from './schema';
 export { SchemaAdapter, NumberSchema, ObjectSchema, UnionSchema, StringSchema, ArraySchema, BooleanSchema, DatetimeSchema, Schema };
 export { schema, number, object, union, string, array, datetime, boolean };
 export { default as compile } from './compile';
 export { modelSchema };
+export default SchemaDomain;
 export function getSchemasWithDefaultAdapter() {
     return {
         number: ()=>NumberSchema.new(),
@@ -34,22 +36,23 @@ export function getSchemasWithDefaultAdapter() {
         union: (...schemas)=>UnionSchema.new(schemas),
         datetime: ()=>DatetimeSchema.new(),
         /**
-     * Different from other models, this function is a factory function that returns either an ObjectSchema or an ArraySchema.
+     * Different from other models, this function is a factory function that returns either an ObjectSchema or
+     * an ArraySchema.
      * The idea is to build the schema of a model dynamically based on its fields.
      *
-     * Another feature is that it can automatically add the foreign key relation to the schema, but for that you need to define
-     * the fields of the related model in the fields object.
+     * Another feature is that it can automatically add the foreign key relation to the schema,
+     * but for that you need to define the fields of the related model in the fields object.
      *
-     * For example: A User model have a field `companyId` that is a ForeignKeyField to the Company model. The `relationName`
-     * is the direct relation from the User model to the Company model, and the `relatedName` is the reverse relation from the
-     * Company model to the User model. If you define the fieldName as either the relatedName or the relationName it will fetch
-     * the data automatically.
+     * For example: A User model have a field `companyId` that is a ForeignKeyField to the Company model.
+     * The `relationName` is the direct relation from the User model to the Company model, and the `relatedName`
+     * is the reverse relation from the Company model to the User model. If you define the fieldName as either
+     * the relatedName or the relationName it will fetch the data automatically.
      *
-     * **Important**: We build the schema dynamically but also lazily, if you don't try to parse or validate the schema, it won't be built.
-     * After the first time it's built, it's cached and never built again.
+     * **Important**: We build the schema dynamically but also lazily, if you don't try to parse or validate the
+     * schema, it won't be built. After the first time it's built, it's cached and never built again.
      *
-     * **Important 2**: If you want to use the automatic relation feature, you need to define guarantee that the foreignKey field fieldName
-     * exists on `show` array, or that it doesn't exist on `omit` array.
+     * **Important 2**: If you want to use the automatic relation feature, you need to define guarantee that the
+     * foreignKey field fieldName exists on `show` array, or that it doesn't exist on `omit` array.
      *
      * Like: `{ options: { show: ['id', 'name', 'companyId'] }}` or `{ options: { omit: ['id'] }}` it **will work**.
      *
@@ -104,57 +107,19 @@ export function getSchemasWithDefaultAdapter() {
      *   show: ['id', 'type']
      * });
      *```
-    * @param model - The model that you want to build the schema from.
-    * @param options - The options to build the schema.
-    * @param options.ignoreExtraneousFields - If you want to ignore extraneous fields set this to true.
-    * @param options.engineInstance - What engine instance you want to use to fetch the data. Defaults to the first one.
-    * @param options.fields - Extra fields that you want to add to the schema. If it has the same name as the model field,
-    * We will not create a schema for that field and use the one you have defined here.
-    * @param options.omit - Fields that you want to omit from the schema. If that is defined, we ignore `show` option.
-    * @param options.show - Fields that you want to show on the schema. If that is defined, we ignore `omit` option.
-    * @param options.many - If you want to return an array instead of an object, set this to true. With that we create
-    * an ArraySchema instead of an ObjectSchema.
-    *
-    * @returns - If you pass the `many` option as true, we return an ArraySchema, otherwise we return an ObjectSchema.
-    */ modelSchema: (model, options)=>modelSchema(model, options)
+     * @param model - The model that you want to build the schema from.
+     * @param options - The options to build the schema.
+     * @param options.ignoreExtraneousFields - If you want to ignore extraneous fields set this to true.
+     * @param options.engineInstance - What engine instance you want to use to fetch the data.
+     * Defaults to the first one.
+     * @param options.fields - Extra fields that you want to add to the schema. If it has the same name as the
+     * model field, We will not create a schema for that field and use the one you have defined here.
+     * @param options.omit - Fields that you want to omit from the schema. If that is defined, we ignore `show` option.
+     * @param options.show - Fields that you want to show on the schema. If that is defined, we ignore `omit` option.
+     * @param options.many - If you want to return an array instead of an object, set this to true. With that we create
+     * an ArraySchema instead of an ObjectSchema.
+     *
+     * @returns - If you pass the `many` option as true, we return an ArraySchema, otherwise we return an ObjectSchema.
+     */ modelSchema: (model, options)=>modelSchema(model, options)
     };
-} /*
-export class User extends Model<User>() {
-  fields = {
-    id: AutoField.new(),
-    uuid: UuidField.new({
-      autoGenerate: true
-    }),
-    name: CharField.new({ maxLength: 255, dbIndex: true, allowNull: true }),
-    age: IntegerField.new({ dbIndex: true }),
-    userType: EnumField.new({ choices: ['admin', 'user'], defaultValue: 'admin' }),
-    price: DecimalField.new({ maxDigits: 5, decimalPlaces: 2, allowNull: true }),
-    isActive: BooleanField.new({ defaultValue: true }),
-    companyId: ForeignKeyField.new({
-      onDelete: ON_DELETE.CASCADE,
-      relatedName: 'usersOfCompany',
-      relationName: 'company',
-      toField: 'id',
-      relatedTo: Company
-    }),
-    updatedAt: DateField.new({ autoNow: true }),
-    createdAt: DateField.new({ autoNowAdd: true }),
-  }
-
-  options: ModelOptionsType<User> = {
-    tableName: 'users',
-  }
-}
-
-export class Company extends Model<Company>() {
-  fields = {
-    id: AutoField.new(),
-    name: CharField.new({ maxLength: 255 }),
-    address: CharField.new({ maxLength: 255, allowNull: true }),
-  }
-
-  options: ModelOptionsType<Company> = {
-    tableName: 'companies',
-  }
 }
-*/ 

package/dist/esm/src/model.js

@@ -84,22 +84,22 @@ async function getSchemaFromModelField(model, field, parent, definedFields, engi
     return schema || string();
 }
 /**
- * Different from other schemas, this function is a factory function that returns either an ObjectSchema or an ArraySchema.
- * The idea is to build the schema of a model dynamically based on its fields.
+ * Different from other schemas, this function is a factory function that returns either an ObjectSchema or an
+ * ArraySchema. The idea is to build the schema of a model dynamically based on its fields.
  *
- * Another feature is that it can automatically add the foreign key relation to the schema, but for that you need to define
- * the fields of the related model in the fields object.
+ * Another feature is that it can automatically add the foreign key relation to the schema, but for that you need to
+ * define the fields of the related model in the fields object.
  *
  * For example: A User model have a field `companyId` that is a ForeignKeyField to the Company model. The `relationName`
- * is the direct relation from the User model to the Company model, and the `relatedName` is the reverse relation from the
- * Company model to the User model. If you define the fieldName as either the relatedName or the relationName it will fetch
- * the data automatically.
+ * is the direct relation from the User model to the Company model, and the `relatedName` is the reverse relation from
+ * the Company model to the User model. If you define the fieldName as either the relatedName or the relationName it
+ * will fetch the data automatically.
  *
- * **Important**: We build the schema dynamically but also lazily, if you don't try to parse or validate the schema, it won't be built.
- * After the first time it's built, it's cached and never built again.
+ * **Important**: We build the schema dynamically but also lazily, if you don't try to parse or validate the schema, it
+ * won't be built. After the first time it's built, it's cached and never built again.
  *
- * **Important 2**: If you want to use the automatic relation feature, you need to define guarantee that the foreignKey field fieldName
- * exists on `show` array, or that it doesn't exist on `omit` array.
+ * **Important 2**: If you want to use the automatic relation feature, you need to define guarantee that the foreignKey
+ * field fieldName exists on `show` array, or that it doesn't exist on `omit` array.
  *
  * Like: `{ options: { show: ['id', 'name', 'companyId'] }}` or `{ options: { omit: ['id'] }}` it **will work**.
  *
@@ -152,16 +152,16 @@ async function getSchemaFromModelField(model, field, parent, definedFields, engi
  *   fields: {
  *      usersOfCompany: p.modelSchema(User, { many: true }).optional({ outputOnly: true });
  *   },
- *   show: ['id', 'type'] // The `companyId` field on the 'User' model is tied to the `id` field on the 'Company' model so 'id' is required.
- * });
+ *   // The `companyId` field on the 'User' model is tied to the `id` field on the 'Company' model so 'id' is required.
+ *   show: ['id', 'type'] * });
  *```
  * @param model - The model that you want to build the schema from.
  * @param options - The options to build the schema.
  * @param options.ignoreExtraneousFields - If you want to ignore extraneous fields set this to true.
  * @param options.engineInstance - What engine instance you want to use to fetch the data. Defaults to the first one.
- * @param options.omitRelation - Fields that you want to omit from the relation. For example, on the example above, on the
- * `userSchema` you can omit the `companyId` field from the relation by just passing `['company']`, on the `companySchema`
- * you can omit the `id` field from company by passing `['usersOfCompany']`.
+ * @param options.omitRelation - Fields that you want to omit from the relation. For example, on the example above, on
+ * the `userSchema` you can omit the `companyId` field from the relation by just passing `['company']`, on the
+ * `companySchema`  you can omit the `id` field from company by passing `['usersOfCompany']`.
  *
  * @param options.fields - Extra fields that you want to add to the schema. If it has the same name as the model field,
  * We will not create a schema for that field and use the one you have defined here.
@@ -187,68 +187,73 @@ async function getSchemaFromModelField(model, field, parent, definedFields, engi
     lazyModelSchema.__model = model;
     // Add this callback to transform the model fields
     parentSchema.__runBeforeParseAndData = async ()=>{
-        if (parentSchema.__alreadyAppliedModel) return;
-        parentSchema.__alreadyAppliedModel = true;
-        const fieldsOfModels = model._fields();
-        const fieldsAsEntries = Object.entries(fieldsOfModels);
-        const fieldsWithAutomaticRelations = new Map();
-        const fields = await fieldsAsEntries.reduce(async (accumulatorAsPromise, [key, value])=>{
-            if (omitAsSet.has(key)) return accumulatorAsPromise;
-            if (showAsSet.size > 0 && !showAsSet.has(key)) return accumulatorAsPromise;
-            let schema = fieldsAsObject[key];
-            const optionsForForeignKeyRelation = {};
-            if (!schema || value instanceof ForeignKeyField) {
-                const newSchema = await getSchemaFromModelField(model, value, parentSchema?.__getParent?.(), options?.fields, options?.engineInstance, optionsForForeignKeyRelation);
-                if (!schema) schema = newSchema;
-            }
-            // Appends the foreign key relation to the schema automatically.
-            if (optionsForForeignKeyRelation.foreignKeyRelation) {
-                const rootSchema = optionsForForeignKeyRelation?.foreignKeyRelation?.schema || lazyModelSchema;
-                const existingRelations = fieldsWithAutomaticRelations.get(rootSchema) || [];
-                existingRelations.push({
-                    relationOrRelatedName: optionsForForeignKeyRelation.foreignKeyRelation.relationOrRelatedName,
-                    isArray: optionsForForeignKeyRelation.foreignKeyRelation.isArray,
-                    model: optionsForForeignKeyRelation.foreignKeyRelation.model,
-                    fieldToSearchOnModel: optionsForForeignKeyRelation.foreignKeyRelation.fieldToSearchOnModel,
-                    fieldToGetFromData: optionsForForeignKeyRelation.foreignKeyRelation.fieldToGetFromData
-                });
-                fieldsWithAutomaticRelations.set(rootSchema, existingRelations);
-            }
-            const accumulator = await accumulatorAsPromise;
-            accumulator[key] = schema;
-            return accumulator;
-        }, Promise.resolve(fieldsAsObject));
-        if (fieldsWithAutomaticRelations.size > 0) {
-            // This way we can get all of the relations concurrently with Promise.all
-            for (const [schema, relations] of fieldsWithAutomaticRelations.entries()){
-                schema.toRepresentation(async (data)=>{
-                    const allData = Array.isArray(data) ? data : [
-                        data
-                    ];
-                    // since we are changing the data by reference, just return the data itself.
-                    await Promise.all(allData.map(async (data)=>Promise.all(relations.map(async (relation)=>{
-                            // Ignore if the data of the relation already exists
-                            if (relation.relationOrRelatedName in data) return;
-                            let relationData = await relation.model.default.get({
-                                search: {
-                                    [relation.fieldToSearchOnModel]: data[relation.fieldToGetFromData]
-                                }
-                            });
-                            if (relation.isArray !== true) relationData = relationData[0];
-                            data[relation.relationOrRelatedName] = relationData;
-                            if (schema.__omitRelation.has(relation.relationOrRelatedName)) delete data[relation.fieldToGetFromData];
-                        }))));
-                    return data;
-                }, {
-                    after: true
-                });
-            }
-        }
-        lazyModelSchema.__data = fields;
-        await Promise.all(customFieldValues.map(async (schema)=>{
-            schema['__getParent'] = ()=>lazyModelSchema;
-            if (schema['__runBeforeParseAndData']) await schema['__runBeforeParseAndData'](schema);
-        }));
+        const promise = new Promise((resolve)=>{
+            const fieldsOfModels = model._fields();
+            const fieldsAsEntries = Object.entries(fieldsOfModels);
+            const fieldsWithAutomaticRelations = new Map();
+            const fields = fieldsAsObject;
+            Promise.all(fieldsAsEntries.map(async ([key, value])=>{
+                if (omitAsSet.has(key)) return;
+                if (showAsSet.size > 0 && !showAsSet.has(key)) return;
+                let schema = fieldsAsObject[key];
+                const optionsForForeignKeyRelation = {};
+                if (!schema || value instanceof ForeignKeyField) {
+                    const newSchema = await getSchemaFromModelField(model, value, parentSchema?.__getParent?.(), options?.fields, options?.engineInstance, optionsForForeignKeyRelation);
+                    if (!schema) schema = newSchema;
+                }
+                // Appends the foreign key relation to the schema automatically.
+                if (optionsForForeignKeyRelation.foreignKeyRelation) {
+                    const rootSchema = optionsForForeignKeyRelation?.foreignKeyRelation?.schema || lazyModelSchema;
+                    const existingRelations = fieldsWithAutomaticRelations.get(rootSchema) || [];
+                    existingRelations.push({
+                        relationOrRelatedName: optionsForForeignKeyRelation.foreignKeyRelation.relationOrRelatedName,
+                        isArray: optionsForForeignKeyRelation.foreignKeyRelation.isArray,
+                        model: optionsForForeignKeyRelation.foreignKeyRelation.model,
+                        fieldToSearchOnModel: optionsForForeignKeyRelation.foreignKeyRelation.fieldToSearchOnModel,
+                        fieldToGetFromData: optionsForForeignKeyRelation.foreignKeyRelation.fieldToGetFromData
+                    });
+                    fieldsWithAutomaticRelations.set(rootSchema, existingRelations);
+                }
+                fieldsAsObject[key] = schema;
+                return fieldsAsObject;
+            })).then(async ()=>{
+                if (fieldsWithAutomaticRelations.size > 0) {
+                    // This way we can get all of the relations concurrently with Promise.all
+                    for (const [schema, relations] of fieldsWithAutomaticRelations.entries()){
+                        schema.toRepresentation(async (data)=>{
+                            const allData = Array.isArray(data) ? data : [
+                                data
+                            ];
+                            // since we are changing the data by reference, just return the data itself.
+                            await Promise.all(allData.map(async (data)=>Promise.all(relations.map(async (relation)=>{
+                                    // Ignore if the data of the relation already exists
+                                    if (relation.relationOrRelatedName in data) return;
+                                    let relationData = await relation.model.default.get({
+                                        search: {
+                                            [relation.fieldToSearchOnModel]: data[relation.fieldToGetFromData]
+                                        }
+                                    });
+                                    if (relation.isArray !== true) relationData = relationData[0];
+                                    data[relation.relationOrRelatedName] = relationData;
+                                    if (schema.__omitRelation.has(relation.relationOrRelatedName)) delete data[relation.fieldToGetFromData];
+                                }))));
+                            return data;
+                        }, {
+                            after: true
+                        });
+                    }
+                }
+                lazyModelSchema.__data = fields;
+                await Promise.all(customFieldValues.map(async (schema)=>{
+                    schema['__getParent'] = ()=>lazyModelSchema;
+                    if (schema['__runBeforeParseAndData']) await schema['__runBeforeParseAndData'](schema);
+                }));
+                resolve(undefined);
+            });
+        });
+        if (parentSchema.__alreadyAppliedModel) return parentSchema.__alreadyAppliedModel;
+        parentSchema.__alreadyAppliedModel = promise;
+        return promise;
     };
     if (options?.ignoreExtraneousFields !== true) lazyModelSchema.removeExtraneous();
     return parentSchema;