@palmares/schemas 0.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../../src/validators/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,EAAwC,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAE1G,wBAAgB,gBAAgB,CAAC,cAAc,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,4BAA4B,CAmDxG"}

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

@@ -0,0 +1,10 @@
+import type BooleanSchema from '../schema/boolean';
+import type NumberSchema from '../schema/number';
+import type Schema from '../schema/schema';
+import type StringSchema from '../schema/string';
+import type { ValidationFallbackReturnType } from '../schema/types';
+export declare function optional(args: Schema['__optional']): ValidationFallbackReturnType;
+export declare function nullable(args: Schema['__nullable']): ValidationFallbackReturnType;
+export declare function checkType(args: Schema['__type']): ValidationFallbackReturnType;
+export declare function is(args: BooleanSchema['__is'] | NumberSchema['__is'] | StringSchema['__is']): ValidationFallbackReturnType;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/validators/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,aAAa,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,YAAY,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,YAAY,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAEpE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,4BAA4B,CAkCjF;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,4BAA4B,CAkCjF;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,4BAA4B,CA2B9E;AAED,wBAAgB,EAAE,CAChB,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,GACxE,4BAA4B,CAuB9B"}

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

@@ -0,0 +1,12 @@
+import type StringSchema from '../schema/string';
+import { type ValidationFallbackReturnType } from '../schema/types';
+export declare function stringValidation(): ValidationFallbackReturnType;
+export declare function maxLength(args: StringSchema['__maxLength']): ValidationFallbackReturnType;
+export declare function minLength(args: StringSchema['__maxLength']): ValidationFallbackReturnType;
+export declare function endsWith(args: StringSchema['__endsWith']): ValidationFallbackReturnType;
+export declare function startsWith(args: StringSchema['__startsWith']): ValidationFallbackReturnType;
+export declare function includes(args: StringSchema['__includes']): ValidationFallbackReturnType;
+export declare function regex(args: StringSchema['__regex']): ValidationFallbackReturnType;
+export declare function uuid(args: StringSchema['__uuid']): ValidationFallbackReturnType;
+export declare function email(args: StringSchema['__email']): ValidationFallbackReturnType;
+//# sourceMappingURL=string.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../src/validators/string.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,YAAY,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAEpE,wBAAgB,gBAAgB,IAAI,4BAA4B,CAoB/D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,aAAa,CAAC,GAAG,4BAA4B,CAqBzF;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,aAAa,CAAC,GAAG,4BAA4B,CAqBzF;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,YAAY,CAAC,GAAG,4BAA4B,CAqBvF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,CAAC,cAAc,CAAC,GAAG,4BAA4B,CAqB3F;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,YAAY,CAAC,GAAG,4BAA4B,CAqBvF;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,SAAS,CAAC,GAAG,4BAA4B,CAqBjF;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,4BAA4B,CAyB/E;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,SAAS,CAAC,GAAG,4BAA4B,CAsBjF"}

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

@@ -0,0 +1,2 @@
+export type ValidatorTypes = 'low' | 'medium' | 'high';
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/validators/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC"}

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

@@ -0,0 +1,4 @@
+import type Schema from '../schema/schema';
+import type { ValidationFallbackReturnType } from '../schema/types';
+export declare function unionValidation(schemas: readonly [Schema<any, any>, Schema<any, any>, ...Schema<any, any>[]]): ValidationFallbackReturnType;
+//# sourceMappingURL=union.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../../../src/validators/union.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAEpE,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAC5E,4BAA4B,CA8C9B"}

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

@@ -0,0 +1,83 @@
+import type { ValidatorTypes } from './types';
+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.
+ *
+ * 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.
+ *
+ * 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;
+    priority: number;
+    fallbacks: ((value: any, path: (string | number)[], options: Parameters<Schema['__transformToAdapter']>[0]) => Promise<{
+        parsed: any;
+        errors: {
+            isValid: boolean;
+            code: ErrorCodes;
+            message: string;
+            path: (string | number)[];
+        }[];
+        preventChildValidation?: boolean;
+    }>)[];
+    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.
+     *
+     * 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.
+     *
+     * 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.
+     * @param fallback - The fallback function that we are adding.
+     * @param childOrParent - If we are adding a fallback to the child or to the parent.
+     * @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;
+    /**
+     * 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 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.
+     */
+    validate(errorsAsHashedSet: Set<string>, path: ValidationFallbackCallbackReturnType['errors'][number]['path'], parseResult: {
+        errors: undefined | ValidationFallbackCallbackReturnType['errors'];
+        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.
+     *
+     * @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;
+        removeCurrent?: boolean;
+    }): Validator;
+    toString(ident?: number): string;
+}
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,13 @@
+import FieldAdapter from '.';
+export function arrayFieldAdapter(args) {
+    class CustomArrayFieldAdapter extends ArrayFieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomArrayFieldAdapter;
+}
+export default class ArrayFieldAdapter extends FieldAdapter {
+    translate(_fieldAdapter, _args) {}
+}

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

@@ -0,0 +1,20 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+export function booleanFieldAdapter(args) {
+    class CustomBooleanFieldAdapter extends BooleanFieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomBooleanFieldAdapter;
+}
+export default class BooleanFieldAdapter extends FieldAdapter {
+    translate(_fieldAdapter, _args) {}
+    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'parse'
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+export function datetimeFieldAdapter(args) {
+    class CustomDatetimeFieldAdapter extends DatetimeFieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomDatetimeFieldAdapter;
+}
+export default class DatetimeFieldAdapter extends FieldAdapter {
+    translate(_fieldAdapter, _args) {}
+    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'parse'
+        });
+    }
+}

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

@@ -0,0 +1,37 @@
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+export function fieldAdapter(args) {
+    class CustomFieldAdapter extends FieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomFieldAdapter;
+}
+export default class FieldAdapter {
+    translate(_fieldAdapter, _args, _base) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'translate'
+        });
+    }
+    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'parse'
+        });
+    }
+    toString(_adapter, _fieldAdapter, _args, _base) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'toString'
+        });
+    }
+    // eslint-disable-next-line ts/require-await
+    async formatError(_adapter, _fieldAdapter, _error, _metadata) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'formatError'
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+export function numberFieldAdapter(args) {
+    class CustomNumberFieldAdapter extends NumberFieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomNumberFieldAdapter;
+}
+export default class NumberFieldAdapter extends FieldAdapter {
+    translate(_fieldAdapter, _args) {}
+    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'parse'
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+export function objectFieldAdapter(args) {
+    class CustomObjectFieldAdapter extends ObjectFieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomObjectFieldAdapter;
+}
+export default class ObjectFieldAdapter extends FieldAdapter {
+    translate(_fieldAdapter, _args) {}
+    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'parse'
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+export function stringFieldAdapter(args) {
+    class CustomStringFieldAdapter extends StringFieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomStringFieldAdapter;
+}
+export default class StringFieldAdapter extends FieldAdapter {
+    translate(_fieldAdapter, _args) {}
+    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'parse'
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+export function unionFieldAdapter(args) {
+    class CustomUnionFieldAdapter extends UnionFieldAdapter {
+        translate = args.translate;
+        toString = args.toString;
+        formatError = args.formatError;
+        parse = args.parse;
+    }
+    return CustomUnionFieldAdapter;
+}
+export default class UnionFieldAdapter extends FieldAdapter {
+    translate(_fieldAdapter, _args) {}
+    parse(_adapter, _fieldAdapter, _result, _value, _args) {
+        throw new SchemaAdapterNotImplementedError({
+            className: this.constructor.name,
+            functionName: 'parse'
+        });
+    }
+}

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

@@ -0,0 +1,18 @@
+import { SchemaAdapterNotImplementedError } from '../exceptions';
+export default class SchemaAdapter {
+    field;
+    number;
+    object;
+    union;
+    string;
+    array;
+    boolean;
+    datetime;
+    // eslint-disable-next-line ts/require-await
+    async formatError(_error, _metadata) {
+        throw new SchemaAdapterNotImplementedError({
+            className: 'SchemaAdapter',
+            functionName: 'formatError'
+        });
+    }
+}

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

@@ -0,0 +1 @@
+export { };

package/dist/esm/src/compile.js

@@ -0,0 +1,10 @@
+import { getDefaultStd } from '@palmares/core';
+import { getDefaultAdapter } from './conf';
+export default async function compile(schemas) {
+    const schemasAsEntries = Object.entries(schemas);
+    const adapter = getDefaultAdapter();
+    const std = getDefaultStd();
+    for (const [keyName, schema] of schemasAsEntries){
+        console.log(await schema.compile(adapter));
+    }
+}

package/dist/esm/src/conf.js

@@ -0,0 +1,19 @@
+import { NoAdapterFoundError } from './exceptions';
+let cachedAdapter = null;
+/**
+ * Sets the default adapter to be used by all of your schemas.
+ *
+ * @param adapter - The adapter to use when you define schemas.
+ */ export function setDefaultAdapter(adapter) {
+    cachedAdapter = adapter;
+}
+/**
+ * Gets the default adapter to be used by all of your schemas.
+ *
+ * @throws {NoAdapterFoundError} - If no adapter has been set.
+ *
+ * @returns The default adapter.
+ */ export function getDefaultAdapter() {
+    if (!cachedAdapter) throw new NoAdapterFoundError();
+    return cachedAdapter;
+}

package/dist/esm/src/constants.js

@@ -0,0 +1,5 @@
+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.`;

package/dist/esm/src/domain.js

@@ -0,0 +1,2 @@
+import { domain } from '@palmares/core';
+export default domain('@palmares/schemas', __dirname, {});

package/dist/esm/src/exceptions.js

@@ -0,0 +1,15 @@
+export class SchemaAdapterNotImplementedError extends Error {
+    constructor(args){
+        super(`Schema adapter did not implement ${args.functionName} in ${args.className}`);
+    }
+}
+export class NoAdapterFoundError extends Error {
+    constructor(){
+        super('No adapter found, please define an adapter using setDefaultAdapter() before using any schema.');
+    }
+}
+export class TranslatableFieldNotImplementedError extends Error {
+    constructor(fieldName){
+        super(`TranslatableField '${fieldName}' did not implement the 'schema' key on 'customAttributes'`);
+    }
+}

package/dist/esm/src/index.js

@@ -0,0 +1,160 @@
+import SchemaAdapter from './adapter';
+import { modelSchema } from './model';
+import ArraySchema, { array } from './schema/array';
+import BooleanSchema, { boolean } from './schema/boolean';
+import DatetimeSchema, { datetime } from './schema/datetime';
+import NumberSchema, { number } from './schema/number';
+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 * 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 function getSchemasWithDefaultAdapter() {
+    return {
+        number: ()=>NumberSchema.new(),
+        string: ()=>StringSchema.new(),
+        array: (...schemas)=>array(...schemas),
+        boolean: ()=>BooleanSchema.new(),
+        object: (data)=>ObjectSchema.new(data),
+        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.
+     * 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.
+     *
+     * 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 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**.
+     *
+     * If you do `{ options: { show: ['id', 'name'] }}` or `{ options: { omit: ['companyId']} }` it **won't work**.
+     *
+     * **Important 3**: If you want to return an array instead of an object, you need to pass the `many` option as true.
+     *
+     * @example
+     * ```typescript
+     * import { auto, choice, foreignKey, Model, define } from '@palmares/databases';
+     * import * as p from '@palmares/schemas';
+     *
+     * const Company = define('Company', {
+     *   fields: {
+     *     id: auto(),
+     *     name: text(),
+     *   },
+     *   options: {
+     *     tableName: 'company',
+     *   }
+     * });
+     *
+     * class User extends Model<User>() {
+     *    fields = {
+     *     id: auto(),
+     *     type: choice({ choices: ['user', 'admin'] }),
+     *     companyId: foreignKey({
+     *        relatedTo: Company,
+     *        relationName: 'company',
+     *        relatedName: 'usersOfCompany',
+     *        toField: 'id',
+     *        onDelete: 'CASCADE',
+     *      }),
+     *   }
+     *
+     *   options = {
+     *     tableName: 'user',
+     *   }
+     * }
+     *
+     * const userSchema = p.modelSchema(User, {
+     *   fields: {
+     *      company: p.modelSchema(Company).optional({ outputOnly: true });
+     *   },
+     *   show: ['type', 'companyId']
+     * });
+     *
+     * const companySchema = p.modelSchema(Company, {
+     *   fields: {
+     *      usersOfCompany: p.modelSchema(User, { many: true }).optional({ outputOnly: true });
+     *   },
+     *   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)
+    };
+} /*
+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',
+  }
+}
+*/