@palmares/schemas 0.1.20 → 0.1.22

package/__tests__/src/core/string.test.ts

@@ -1,222 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('String Schema', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const stringSchema = p.string();
-    const stringSchemaWithCustomMessage = p.string().nonOptional({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse(undefined as any),
-        stringSchemaWithCustomMessage.parse(undefined as any),
-        stringSchema.parse('a')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('required');
-    expect(errorsOnFail?.[0]?.message).toBe('Required');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('a');
-  });
-
-  test('nullable', async ({ expect }) => {
-    const stringSchema = p.string();
-    const stringSchemaWithCustomMessage = p.string().nonNullable({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse(null as any),
-        stringSchemaWithCustomMessage.parse(null as any),
-        stringSchema.parse('a')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('null');
-    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('a');
-  });
-
-  test('is', async ({ expect }) => {
-    const stringSchema = p.string().is(['a', 'b']);
-    const stringSchemaWithCustomMessage = p.string().is(['a', 'b'], { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('c' as any),
-        stringSchemaWithCustomMessage.parse('c' as any),
-        stringSchema.parse('a')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('is');
-    expect(errorsOnFail?.[0]?.message).toBe('The value should be equal to a, b');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('a');
-  });
-
-  test('includes', async ({ expect }) => {
-    const stringSchema = p.string().includes('Hello');
-    const stringSchemaWithCustomMessage = p.string().includes('Hello', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('World'),
-        stringSchemaWithCustomMessage.parse('World'),
-        stringSchema.parse('Hello World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('includes');
-    expect(errorsOnFail?.[0]?.message).toBe(`The string value should include the following substring 'Hello'`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello World');
-  });
-
-  test('maxLength', async ({ expect }) => {
-    const stringSchema = p.string().maxLength(8);
-    const stringSchemaWithCustomMessage = p.string().maxLength(8, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Hello World'),
-        stringSchemaWithCustomMessage.parse('Hello World'),
-        stringSchema.parse('Hello')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('maxLength');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should have a maximum length of 8`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello');
-  });
-
-  test('minLength', async ({ expect }) => {
-    const stringSchema = p.string().minLength(8);
-    const stringSchemaWithCustomMessage = p.string().minLength(8, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse(''),
-        stringSchemaWithCustomMessage.parse(''),
-        stringSchema.parse('Hello World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('minLength');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should have a minimum length of 8`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello World');
-  });
-
-  test('startsWith', async ({ expect }) => {
-    const stringSchema = p.string().startsWith('Hello');
-    const stringSchemaWithCustomMessage = p.string().startsWith('Hello', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('startsWith');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should start with Hello`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('endsWith', async ({ expect }) => {
-    const stringSchema = p.string().endsWith('World');
-    const stringSchemaWithCustomMessage = p.string().endsWith('World', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('endsWith');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should end with World`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('endsWith', async ({ expect }) => {
-    const stringSchema = p.string().endsWith('World');
-    const stringSchemaWithCustomMessage = p.string().endsWith('World', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('endsWith');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should end with World`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('regex', async ({ expect }) => {
-    const regex = new RegExp('Hello', 'g');
-    const stringSchema = p.string().regex(regex);
-    const stringSchemaWithCustomMessage = p.string().regex(regex, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('regex');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should match the following regex '/Hello/g'`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('uuid', async ({ expect }) => {
-    const stringSchema = p.string().uuid();
-    const stringSchemaWithCustomMessage = p.string().uuid({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('f54bb64b-0aed-47f9-976e-a8900d86f6c9')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('uuid');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should be a valid UUID`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('f54bb64b-0aed-47f9-976e-a8900d86f6c9');
-  });
-
-  test('email', async ({ expect }) => {
-    const stringSchema = p.string().email();
-    const stringSchemaWithCustomMessage = p.string().email({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('test@test.com')
-      ]);
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('email');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should be a valid email`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('test@test.com');
-  });
-});

package/__tests__/src/core/test.test.ts

@@ -1,59 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Basic Schemas', ({ test }) => {
-  test('basic representation', async ({ expect }) => {
-    const basicSchema = p.number();
-
-    const data = await basicSchema.data(2);
-
-    expect(data).toBe(2);
-  });
-
-  test('basic to representation', async ({ expect }) => {
-    const defaultMessage = 'This used to be a number';
-    // eslint-disable-next-line ts/require-await
-    const numberSchema = p.number().toRepresentation(async () => {
-      return defaultMessage;
-    });
-
-    // eslint-disable-next-line ts/require-await
-    const schemaTransformingData = p.number().toRepresentation(async (data) => {
-      return {
-        number: data,
-        message: defaultMessage
-      };
-    });
-
-    const stringMessage = await numberSchema.data(2);
-    const objectMessage = await schemaTransformingData.data(2);
-
-    expect(stringMessage).toBe(defaultMessage);
-    expect(objectMessage.message).toBe(defaultMessage);
-    expect(objectMessage.number).toBe(2);
-  });
-
-  test('basic internal', async ({ expect }) => {
-    // eslint-disable-next-line ts/require-await
-    const internalSchema = p.number().toInternal(async (data) => {
-      return data * 2;
-    });
-
-    const { parsed } = await internalSchema.parse(2);
-
-    expect(parsed).toBe(4);
-  });
-
-  test('basic validation', async ({ expect }) => {
-    // eslint-disable-next-line ts/require-await
-    const internalSchema = p.number().toValidate(async () => {
-      return 'Should fail';
-    });
-
-    const { errors } = await internalSchema.parse(2);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-});

package/__tests__/src/core/types.test.ts

@@ -1,97 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Schema Types', ({ test }) => {
-  test('number schema', async ({ expect }) => {
-    const numberSchema = p.number();
-
-    const { errors } = await numberSchema.parse('value' as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('boolean schema', async ({ expect }) => {
-    const booleanSchema = p.boolean();
-
-    const { errors } = await booleanSchema.parse('value' as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('date schema', async ({ expect }) => {
-    const dateSchema = p.datetime();
-
-    const { errors } = await dateSchema.parse('value' as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('string schema', async ({ expect }) => {
-    const stringSchema = p.string();
-
-    const { errors } = await stringSchema.parse(2 as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('array schema', async ({ expect }) => {
-    const tupleSchema = p.array(p.number(), p.string());
-    const arraySchema = p.array([p.number()]);
-
-    const [
-      { errors: errorsOfInvalidArray },
-      { errors: errorsOfInvalidTuple },
-      { errors: errorsOfValidArray, parsed: parsedArray },
-      { errors: errorsOfValidTuple, parsed: parsedTuple }
-    ] = await Promise.all([
-      arraySchema.parse('value' as any),
-      tupleSchema.parse([1, 2, 3] as any),
-      arraySchema.parse([1, 2, 3]),
-      tupleSchema.parse([1, 'string'])
-    ]);
-
-    expect((errorsOfInvalidArray?.length || 0) > 0).toBe(true);
-    expect((errorsOfInvalidTuple?.length || 0) > 0).toBe(true);
-    expect(errorsOfValidArray?.length || 0).toBe(0);
-    expect(errorsOfValidTuple?.length || 0).toBe(0);
-    expect(parsedArray[0]).toBe(1);
-    expect(parsedArray[1]).toBe(2);
-    expect(parsedArray[2]).toBe(3);
-    expect(parsedTuple[0]).toBe(1);
-    expect(parsedTuple[1]).toBe('string');
-  });
-
-  test('object schema', async ({ expect }) => {
-    const objectSchema = p.object({
-      number: p.number(),
-      string: p.string()
-    });
-
-    const [{ errors: errorsOfInvalid }, { errors: errorsOfValid, parsed }] = await Promise.all([
-      objectSchema.parse('value' as any),
-      objectSchema.parse({
-        number: 1,
-        string: 'string'
-      })
-    ]);
-
-    expect((errorsOfInvalid?.length || 0) > 0).toBe(true);
-    expect((errorsOfValid?.length || 0) === 0).toBe(true);
-    expect(parsed.number).toBe(1);
-    expect(parsed.string).toBe('string');
-  });
-
-  test('union schema', async ({ expect }) => {
-    const unionSchema = p.union([p.string(), p.number()]);
-
-    const [{ errors: errorsOfInvalid }, { errors: errorsOfValid, parsed }] = await Promise.all([
-      unionSchema.parse(true as any),
-      unionSchema.parse(2)
-    ]);
-    expect((errorsOfInvalid?.length || 0) > 0).toBe(true);
-    expect((errorsOfValid?.length || 0) === 0).toBe(true);
-    expect(parsed).toBe(2);
-  });
-});

package/__tests__/src/core/union.test.ts

@@ -1,99 +0,0 @@
-import * as p from '@palmares/schemas';
-import { getDefaultAdapter } from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Union Tests', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const unionSchema = p.union([p.number(), p.string()]);
-    const unionSchemaWithCustomMessage = p.union([p.number(), p.string()]).nonOptional({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        unionSchema.parse(undefined as any),
-        unionSchemaWithCustomMessage.parse(undefined as any),
-        unionSchema.parse(1)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('required');
-    expect(errorsOnFail?.[0]?.message).toBe('Required');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(1);
-  });
-
-  test('nullable', async ({ expect }) => {
-    const unionSchema = p.union([p.number(), p.string()]);
-    const unionSchemaWithCustomMessage = p.union([p.number(), p.string()]).nonNullable({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        unionSchema.parse(null as any),
-        unionSchemaWithCustomMessage.parse(null as any),
-        unionSchema.parse('teste')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('null');
-    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('teste');
-  });
-
-  test('in case of failure use the other', async ({ expect }) => {
-    const unionSchema = p.union([p.number().max(20), p.number().min(12)]);
-
-    const { errors, parsed } = await unionSchema.parse(25);
-    expect((errors || []).length).toBe(0);
-    expect(parsed).toBe(25);
-  });
-
-  test('in case of failure, show first', async ({ expect }) => {
-    const unionSchema = p.union([p.number().min(25), p.number().max(20)]);
-
-    const { errors } = await unionSchema.parse(23);
-    expect((errors || []).length > 0).toBe(true);
-  });
-
-  test('works when not defined on adapter', async ({ expect }) => {
-    const adapter = getDefaultAdapter();
-    const existingUnion = adapter.union;
-    adapter.union = undefined;
-    const unionSchema = p.union([p.number().min(25), p.number().max(20)]);
-    const { errors } = await unionSchema.parse(23);
-    expect((errors || []).length > 0).toBe(true);
-
-    adapter.union = existingUnion;
-  });
-
-  test('nested in case of failure use the other', async ({ expect }) => {
-    const unionSchema = p.object({
-      test: p.union([p.number().max(20), p.number().min(12)] as const)
-    });
-
-    const { errors, parsed } = await unionSchema.parse({
-      test: 23
-    });
-    expect((errors || []).length).toBe(0);
-    expect(parsed.test).toBe(23);
-  });
-
-  test('nested in case of failure, show first', async ({ expect }) => {
-    const unionSchema = p.object({ test: p.union([p.number().min(25), p.number().max(20)]) });
-
-    const { errors } = await unionSchema.parse({ test: 23 });
-    expect((errors || []).length > 0).toBe(true);
-  });
-
-  test('nested works when not defined on adapter', async ({ expect }) => {
-    const adapter = getDefaultAdapter();
-    const existingUnion = adapter.union;
-    adapter.union = undefined;
-    const unionSchema = p.object({ test: p.union([p.number().min(25), p.number().max(20)]) });
-    const { errors } = await unionSchema.parse({ test: 23 });
-    expect((errors || []).length > 0).toBe(true);
-
-    adapter.union = existingUnion;
-  });
-});

package/__tests__/src/settings.ts

@@ -1,69 +0,0 @@
-import ConsoleLogging from '@palmares/console-logging';
-import CoreDomain, { defineSettings } from '@palmares/core';
-import DatabasesDomain from '@palmares/databases';
-import DrizzleEngine from '@palmares/drizzle-engine';
-import { drizzle as drizzleBetterSqlite3 } from '@palmares/drizzle-engine/better-sqlite3';
-import JestTestAdapter from '@palmares/jest-tests';
-import LoggingDomain from '@palmares/logging';
-import NodeStd from '@palmares/node-std';
-import SchemasDomain from '@palmares/schemas';
-import TestsDomain from '@palmares/tests';
-import { ZodSchemaAdapter } from '@palmares/zod-schema';
-import Database from 'better-sqlite3';
-import { dirname, resolve } from 'path';
-
-import CustomCoreDomain from './core';
-//import * as schema from '../.drizzle/schema';
-
-const database = new Database('sqlite.db');
-
-const args = DrizzleEngine.new({
-  output: './.drizzle/schema.ts',
-  type: 'better-sqlite3',
-  drizzle: drizzleBetterSqlite3(database)
-});
-export const db = args[1].instance.instance;
-export default defineSettings({
-  basePath: dirname(resolve(__dirname)),
-  settingsLocation: __filename,
-  std: NodeStd,
-  installedDomains: [
-    [
-      LoggingDomain,
-      {
-        logger: ConsoleLogging
-      }
-    ],
-    // Domain Core, required for palmares to work
-    [
-      CoreDomain,
-      {
-        appName: 'example'
-      }
-    ],
-    [
-      TestsDomain,
-      {
-        testAdapter: JestTestAdapter
-      }
-    ],
-    [
-      SchemasDomain,
-      {
-        schemaAdapter: ZodSchemaAdapter
-      }
-    ],
-    [
-      DatabasesDomain,
-      {
-        databases: {
-          default: {
-            engine: args
-          }
-        }
-      }
-    ],
-    // We have just created this custom domain, and it defines our routes.
-    CustomCoreDomain
-  ]
-});

package/__tests__/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "outDir": "./dist",
-    "types": ["node"]
-  },
-  "include": ["./src/**/*", "manage.drizzle.ts", "manage.sequelize.ts", "./src/core/types.test.ts"]
-}

package/src/adapter/fields/array.ts

@@ -1,31 +0,0 @@
-import { FieldAdapter } from '.';
-
-import type { WithFallback } from '../../utils';
-import type { ArrayAdapterTranslateArgs } from '../types';
-
-export function arrayFieldAdapter<
-  TTranslate extends ArrayFieldAdapter['translate'],
-  TToString extends ArrayFieldAdapter['toString'],
-  TFormatError extends ArrayFieldAdapter['formatError'],
-  TParse extends ArrayFieldAdapter['parse']
->(args: { translate: TTranslate; toString?: TToString; formatError?: TFormatError; parse?: TParse }) {
-  class CustomArrayFieldAdapter extends ArrayFieldAdapter {
-    translate = args.translate;
-    toString = args.toString as TToString;
-    formatError = args.formatError as TFormatError;
-    parse = args.parse as TParse;
-  }
-
-  return CustomArrayFieldAdapter as typeof ArrayFieldAdapter & {
-    new (): ArrayFieldAdapter & {
-      translate: TTranslate;
-      toString: TToString;
-      formatError: TFormatError;
-      parse: TParse;
-    };
-  };
-}
-
-export class ArrayFieldAdapter extends FieldAdapter {
-  translate(_fieldAdapter: FieldAdapter, _args: ArrayAdapterTranslateArgs): any | WithFallback<'array'> {}
-}

package/src/adapter/fields/boolean.ts

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

package/src/adapter/fields/datetime.ts

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