@palmares/schemas 0.0.1 → 0.1.0

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

@@ -0,0 +1,222 @@
+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('Hello'),
+        stringSchemaWithCustomMessage.parse('Hello'),
+        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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,71 @@
+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 { User } from '../.drizzle/schema';
+import { eq } from 'drizzle-orm';
+//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

@@ -0,0 +1,11 @@
+{
+  "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/dist/cjs/src/adapter/fields/index.js

@@ -275,7 +275,7 @@ var FieldAdapter = /*#__PURE__*/ function() {
         },
         {
             key: "parse",
-            value: function parse(_adapter, _fieldAdapter, _result, _value, _args) {
+            value: function parse(_adapter, _fieldAdapter, _schema, _value, _args) {
                 throw new _exceptions.SchemaAdapterNotImplementedError({
                     className: this.constructor.name,
                     functionName: 'parse'
@@ -294,7 +294,7 @@ var FieldAdapter = /*#__PURE__*/ function() {
         {
             key: "formatError",
             value: // eslint-disable-next-line ts/require-await
-            function formatError(_adapter, _fieldAdapter, _error, _metadata) {
+            function formatError(_adapter, _fieldAdapter, _schema, _error, _metadata) {
                 var _this = this;
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {

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

@@ -161,6 +161,15 @@ var ObjectFieldAdapter = /*#__PURE__*/ function(FieldAdapter) {
                     functionName: 'parse'
                 });
             }
+        },
+        {
+            key: "toString",
+            value: function toString(_adapter, _fieldAdapter, _args, _base) {
+                throw new _exceptions.SchemaAdapterNotImplementedError({
+                    className: this.constructor.name,
+                    functionName: 'toString'
+                });
+            }
         }
     ]);
     return ObjectFieldAdapter;

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

@@ -177,6 +177,7 @@ var SchemaAdapter = /*#__PURE__*/ function() {
         _define_property(this, "array", void 0);
         _define_property(this, "boolean", void 0);
         _define_property(this, "datetime", void 0);
+        _define_property(this, "adapterInstance", void 0);
     }
     _create_class(SchemaAdapter, [
         {

package/dist/cjs/src/constants.js

@@ -18,9 +18,6 @@ _export(exports, {
     DEFAULT_NUMBER_MIN_EXCEPTION: function() {
         return DEFAULT_NUMBER_MIN_EXCEPTION;
     },
-    DEFAULT_NUMBER_NEGATIVE_EXCEPTION: function() {
-        return DEFAULT_NUMBER_NEGATIVE_EXCEPTION;
-    },
     DEFAULT_NUMBER_POSITIVE_EXCEPTION: function() {
         return DEFAULT_NUMBER_POSITIVE_EXCEPTION;
     }
@@ -31,12 +28,9 @@ var DEFAULT_NUMBER_MAX_EXCEPTION = function(max, inclusive) {
 var DEFAULT_NUMBER_MIN_EXCEPTION = function(min, inclusive) {
     return "The number is less than the allowed ".concat(min, ".").concat(inclusive ? " The value ".concat(min, " is accepted as well.") : '');
 };
-var DEFAULT_NUMBER_NEGATIVE_EXCEPTION = function(allowZero) {
-    return "The number should be negative.".concat(allowZero ? " The value 0 is accepted as well." : '');
-};
 var DEFAULT_NUMBER_POSITIVE_EXCEPTION = function(allowZero) {
     return "The number should be positive.".concat(allowZero ? " The value 0 is accepted as well." : '');
 };
 var DEFAULT_NUMBER_INTEGER_EXCEPTION = function() {
-    return "THe number should be an integer.";
+    return "The number should be an integer.";
 };