@palmares/schemas 0.0.1

package/src/adapter/fields/object.ts

@@ -0,0 +1,49 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+
+import type SchemaAdapter from '..';
+import type WithFallback from '../../utils';
+import type { ObjectAdapterTranslateArgs } from '../types';
+
+
+export function objectFieldAdapter<
+  TTranslate extends ObjectFieldAdapter['translate'],
+  TToString extends ObjectFieldAdapter['toString'],
+  TFormatError extends ObjectFieldAdapter['formatError'],
+  TParse extends ObjectFieldAdapter['parse']
+>(args: {
+  translate: TTranslate;
+  toString?: TToString;
+  formatError?: TFormatError;
+  parse?: TParse;
+}) {
+  class CustomObjectFieldAdapter extends ObjectFieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomObjectFieldAdapter as typeof ObjectFieldAdapter & {
+    new (): ObjectFieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    }
+  }
+}
+
+export default class ObjectFieldAdapter extends FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: ObjectAdapterTranslateArgs): any | WithFallback<'object'> {}
+
+  parse(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _result: any,
+    _value: any,
+    _args: ObjectAdapterTranslateArgs
+  ): Promise<{ errors: any; parsed: any }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
+  }
+}

package/src/adapter/fields/string.ts

@@ -0,0 +1,49 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+
+import type SchemaAdapter from '..';
+import type WithFallback from '../../utils';
+import type { StringAdapterTranslateArgs } from '../types';
+
+
+export function stringFieldAdapter<
+  TTranslate extends StringFieldAdapter['translate'],
+  TToString extends StringFieldAdapter['toString'],
+  TFormatError extends StringFieldAdapter['formatError'],
+  TParse extends StringFieldAdapter['parse']
+>(args: {
+  translate: TTranslate;
+  toString?: TToString;
+  formatError?: TFormatError;
+  parse?: TParse;
+}) {
+  class CustomStringFieldAdapter extends StringFieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomStringFieldAdapter as typeof StringFieldAdapter & {
+    new (): StringFieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    }
+  }
+}
+
+export default class StringFieldAdapter extends FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: StringAdapterTranslateArgs): any | WithFallback<'string'> {}
+
+  parse(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _result: any,
+    _value: any,
+    _args: StringAdapterTranslateArgs
+  ): Promise<{ errors: any; parsed: any }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
+  }
+}

package/src/adapter/fields/union.ts

@@ -0,0 +1,49 @@
+import FieldAdapter from '.';
+import { SchemaAdapterNotImplementedError } from '../../exceptions';
+
+import type SchemaAdapter from '..';
+import type WithFallback from '../../utils';
+import type { UnionAdapterTranslateArgs } from '../types';
+
+
+export function unionFieldAdapter<
+  TTranslate extends UnionFieldAdapter['translate'],
+  TToString extends UnionFieldAdapter['toString'],
+  TFormatError extends UnionFieldAdapter['formatError'],
+  TParse extends UnionFieldAdapter['parse']
+>(args: {
+  translate: TTranslate;
+  toString?: TToString;
+  formatError?: TFormatError;
+  parse?: TParse;
+}) {
+  class CustomUnionFieldAdapter extends UnionFieldAdapter {
+    translate = args.translate;
+    toString = args.toString as TToString;
+    formatError = args.formatError as TFormatError;
+    parse = args.parse as TParse;
+  }
+
+  return CustomUnionFieldAdapter as typeof UnionFieldAdapter & {
+    new (): UnionFieldAdapter & {
+      translate: TTranslate;
+      toString: TToString;
+      formatError: TFormatError;
+      parse: TParse;
+    }
+  }
+}
+
+export default class UnionFieldAdapter extends FieldAdapter {
+  translate(_fieldAdapter: FieldAdapter, _args: UnionAdapterTranslateArgs): any | WithFallback<'union'> {}
+
+  parse(
+    _adapter: SchemaAdapter,
+    _fieldAdapter: FieldAdapter,
+    _result: any,
+    _value: any,
+    _args: UnionAdapterTranslateArgs
+  ): Promise<{ errors: any; parsed: any }> {
+    throw new SchemaAdapterNotImplementedError({ className: this.constructor.name, functionName: 'parse' });
+  }
+}

package/src/adapter/index.ts

@@ -0,0 +1,34 @@
+import { SchemaAdapterNotImplementedError } from '../exceptions';
+
+import type FieldAdapter from './fields';
+import type ArrayFieldAdapter from './fields/array';
+import type BooleanFieldAdapter from './fields/boolean';
+import type DatetimeFieldAdapter from './fields/datetime';
+import type NumberFieldAdapter from './fields/number';
+import type ObjectFieldAdapter from './fields/object';
+import type StringFieldAdapter from './fields/string';
+import type UnionFieldAdapter from './fields/union';
+import type { ErrorCodes } from './types';
+
+export default class SchemaAdapter {
+  field!: FieldAdapter;
+  number?: NumberFieldAdapter;
+  object!: ObjectFieldAdapter;
+  union?: UnionFieldAdapter;
+  string?: StringFieldAdapter;
+  array?: ArrayFieldAdapter;
+  boolean?: BooleanFieldAdapter;
+  datetime?: DatetimeFieldAdapter;
+
+  // eslint-disable-next-line ts/require-await
+  async formatError(
+    _error: any,
+    _metadata?: any
+  ): Promise<{
+    message: string;
+    path: (string | number)[];
+    code: ErrorCodes;
+  }> {
+    throw new SchemaAdapterNotImplementedError({ className: 'SchemaAdapter', functionName: 'formatError' });
+  }
+}

package/src/adapter/types.ts

@@ -0,0 +1,261 @@
+import type Schema from '../schema/schema';
+import type { SupportedSchemas } from '../types';
+import type { withFallbackFactory } from '../utils';
+
+export type NonToTranslateArgs<TType extends SupportedSchemas> = {
+  withFallback: ReturnType<typeof withFallbackFactory<TType>>;
+};
+
+export type AdapterToStringArgs = {
+  parsers: {
+    optional: Schema['__optional']['allow'];
+    nullable: Schema['__nullable']['allow'];
+  };
+  optional: Schema['__optional'];
+  nullable: Schema['__nullable'];
+};
+
+export type AdapterTranslateArgs<TType extends SupportedSchemas = SupportedSchemas> = AdapterToStringArgs & NonToTranslateArgs<TType>;
+
+export type DatetimeAdapterTranslateArgs = {
+  allowString: boolean | undefined;
+  above: {
+    value: Date;
+    inclusive: boolean;
+    message: string;
+  };
+  below: {
+    value: Date;
+    inclusive: boolean;
+    message: string;
+  };
+} & AdapterTranslateArgs<'datetime'>;
+
+export type BooleanAdapterTranslateArgs = {
+  parsers: {
+    allowString: boolean | undefined;
+    allowNumber: boolean | undefined;
+    trueValues: any[];
+    falseValues: any[];
+    is: boolean;
+  } & AdapterTranslateArgs<'boolean'>['parsers'];
+  is: {
+    value: boolean;
+    message: string;
+  };
+} & AdapterTranslateArgs<'boolean'>;
+
+export type ArrayAdapterTranslateArgs = {
+  minLength:
+    | {
+        value: number;
+        inclusive: boolean;
+        message: string;
+      }
+    | undefined;
+  maxLength:
+    | {
+        value: number;
+        inclusive: boolean;
+        message: string;
+      }
+    | undefined;
+  nonEmpty:
+    | {
+        message: string;
+      }
+    | undefined;
+
+  isTuple: boolean;
+} & AdapterTranslateArgs<'array'>;
+
+export type NumberAdapterTranslateArgs = {
+  is:
+    | {
+        value: number[];
+        message: string;
+      }
+    | undefined;
+  min:
+    | {
+        value: number;
+        inclusive: boolean;
+        message: string;
+      }
+    | undefined;
+  max:
+    | {
+        value: number;
+        inclusive: boolean;
+        message: string;
+      }
+    | undefined;
+  maxDigits:
+    | {
+        value: number;
+        message: string;
+      }
+    | undefined;
+  decimalPlaces:
+    | {
+        value: number;
+        message: string;
+      }
+    | undefined;
+  allowNegative:
+    | {
+        allowZero: boolean;
+        message: string;
+      }
+    | undefined;
+  allowPositive:
+    | {
+        allowZero: boolean;
+        message: string;
+      }
+    | undefined;
+  integer:
+    | {
+        message: string;
+      }
+    | undefined;
+} & AdapterTranslateArgs<'number'>;
+
+export type StringAdapterToStringArgs = Omit<StringAdapterTranslateArgs, keyof NonToTranslateArgs<'string'>>;
+
+export type StringAdapterTranslateArgsWithoutNonTranslateArgs = Omit<
+  StringAdapterTranslateArgs,
+  keyof NonToTranslateArgs<'string'>
+>;
+
+export type StringAdapterTranslateArgs = {
+  minLength:
+    | {
+        value: number;
+        inclusive: boolean;
+        message: string;
+      }
+    | undefined;
+  maxLength:
+    | {
+        value: number;
+        inclusive: boolean;
+        message: string;
+      }
+    | undefined;
+  regex:
+    | {
+        value: RegExp;
+        message: string;
+      }
+    | undefined;
+  endsWith:
+    | {
+        value: string;
+        message: string;
+      }
+    | undefined;
+  startsWith:
+    | {
+        value: string;
+        message: string;
+      }
+    | undefined;
+  includes:
+    | {
+        value: string;
+        message: string;
+      }
+    | undefined;
+} & AdapterTranslateArgs<'string'>;
+
+export type NumberAdapterToStringArgs = Omit<NumberAdapterTranslateArgs, keyof NonToTranslateArgs<'number'>>;
+
+export type NumberAdapterTranslateArgsWithoutNonTranslateArgs = Omit<
+  NumberAdapterTranslateArgs,
+  keyof NonToTranslateArgs<'number'>
+>;
+
+export type ObjectAdapterTranslateArgs = {
+  data: Record<string, any>;
+} & AdapterTranslateArgs<'object'>;
+
+export type ObjectAdapterToStringArgs = {
+  data: Record<string, string>;
+} & AdapterToStringArgs;
+
+export type UnionAdapterTranslateArgs<TSchemasType = any> = {
+  schemas: TSchemasType;
+} & AdapterTranslateArgs<'union'>;
+
+export type UnionAdapterToStringArgs = {
+  schemas: [string, string, ...string[]];
+} & AdapterToStringArgs;
+
+export type UnionAdapterTranslateArgsWithoutNonTranslateArgs = Omit<
+  UnionAdapterTranslateArgs,
+  keyof NonToTranslateArgs<'union'>
+>;
+
+export type ObjectAdapterTranslateArgsWithoutNonTranslateArgs = Omit<
+  ObjectAdapterTranslateArgs,
+  keyof NonToTranslateArgs<'object'>
+>;
+
+export type ArrayAdapterTranslateArgsWithoutNonTranslateArgs = Omit<
+  ArrayAdapterTranslateArgs,
+  keyof NonToTranslateArgs<'array'>
+>;
+
+export type BooleanAdapterTranslateArgsWithoutNonTranslateArgs = Omit<
+  BooleanAdapterTranslateArgs,
+  keyof NonToTranslateArgs<'boolean'>
+>;
+
+export type DatetimeAdapterTranslateArgsWithoutNonTranslateArgs = Omit<
+  DatetimeAdapterTranslateArgs,
+  keyof NonToTranslateArgs<'datetime'>
+>;
+export type ValidationDataBasedOnType<TType> = TType extends 'number'
+  ? NumberAdapterTranslateArgsWithoutNonTranslateArgs
+  : TType extends 'union'
+  ? UnionAdapterTranslateArgsWithoutNonTranslateArgs
+  : TType extends 'string'
+  ? StringAdapterTranslateArgsWithoutNonTranslateArgs
+  : TType extends 'array'
+  ? ArrayAdapterTranslateArgsWithoutNonTranslateArgs
+  : TType extends 'boolean'
+  ? BooleanAdapterTranslateArgsWithoutNonTranslateArgs
+  : TType extends 'datetime'
+  ? DatetimeAdapterTranslateArgsWithoutNonTranslateArgs
+  : ObjectAdapterTranslateArgsWithoutNonTranslateArgs;
+
+export type ErrorCodes =
+  | 'max'
+  | 'negative'
+  | 'positive'
+  | 'maxDigits'
+  | 'decimalPlaces'
+  | 'min'
+  | 'integer'
+  | 'required'
+  | 'object'
+  | 'number'
+  | 'string'
+  | 'array'
+  | 'tuple'
+  | 'nonEmpty'
+  | 'datetime'
+  | 'is'
+  | 'above'
+  | 'below'
+  | 'boolean'
+  | 'minLength'
+  | 'maxLength'
+  | 'regex'
+  | 'uuid'
+  | 'email'
+  | 'includes'
+  | 'endsWith'
+  | 'startsWith'
+  | `customError${string}`;

package/src/compile.ts

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

package/src/conf.ts

@@ -0,0 +1,27 @@
+import { NoAdapterFoundError } from './exceptions';
+
+import type SchemaAdapter from './adapter';
+
+let cachedAdapter: SchemaAdapter | null = 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: SchemaAdapter) {
+  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(): SchemaAdapter {
+  if (!cachedAdapter) throw new NoAdapterFoundError();
+
+  return cachedAdapter;
+}

package/src/constants.ts

@@ -0,0 +1,9 @@
+export const DEFAULT_NUMBER_MAX_EXCEPTION = (max: number, inclusive: boolean) =>
+  `The number is greater than the allowed ${max}.${inclusive ? ` The value ${max} is accepted as well.` : ''}`;
+export const DEFAULT_NUMBER_MIN_EXCEPTION = (min: number, inclusive: boolean) =>
+  `The number is less than the allowed ${min}.${inclusive ? ` The value ${min} is accepted as well.` : ''}`;
+export const DEFAULT_NUMBER_NEGATIVE_EXCEPTION = (allowZero: boolean) =>
+  `The number should be negative.${allowZero ? ` The value 0 is accepted as well.` : ''}`;
+export const DEFAULT_NUMBER_POSITIVE_EXCEPTION = (allowZero: boolean) =>
+  `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/src/domain.ts

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

package/src/exceptions.ts

@@ -0,0 +1,17 @@
+export class SchemaAdapterNotImplementedError extends Error {
+  constructor(args: { className: string; functionName: string }) {
+    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: string) {
+    super(`TranslatableField '${fieldName}' did not implement the 'schema' key on 'customAttributes'`);
+  }
+}