schematox 0.0.3 → 0.0.5

package/README.md

@@ -4,19 +4,17 @@ SchmatoX is a lightweight library for creating JSON compatible schemas. The subj
 
 ## Pros
 
-- The statically defined JSON compatible schema is a killer feature:
-  - It has great potential for automation in the context of DB model creation, CRUD backends, documentation, outer interface requirements etc.
-  - One can store schema changes as static JSON and potentially use it for creating coherent DB Model migration logic.
-  - One can check if the defined schema is compatible with our constraints using the "as const satisfies Schema".
-- Programmatically defined schemas are also supported, but as a means of creating statically defined schemas.
-- There is a clear separation of concerns for validating and parsing logic.
-  - The Schematox parser is used for dealing with an outer interface where the data type is not guaranteed.
-  - The Schematox validator is used for dealing with an internal interface where the data type is known.
-- Schematox uses an Ether-style error handling system. It never throws an error on an unsuccessful schema subject check. Instead, our parser/validator always returns an `EitherError` object.
-- We offer first-class support for branded base schema types.
+- The statically defined JSON compatible schema
+- Check defined schema correctness using non generic type `Schema`
+- Programmatically defined schemas supported as mean of creation statically defined schema
+- Clear separation of concerns for validating and parsing logic:
+  - Parser is used for dealing with an outer uknnown interface
+  - Validator is used for dealing with an internal known interface
+- Schematox uses an Ether-style error handling
+- We offer first-class support for branded base schema primitive types
 - We have zero dependencies. The runtime code logic is small and easy to grasp, consisting of just a couple of functions. Most of the library code is tests and types.
 
-Essentially, to define a schema, one doesn't even need to import any functions from our library, only the `Schema` type. This approach does come with a few limitations. The first is `stringUnion` and `numberUnion` schema default values are not constrained by the defined union choices, only the primitive type. We might fix this issue later, but for now, we prioritize this over the case when `default` extends union choice by its definition.
+Essentially, to define a schema, one doesn't need to import any functions from our library, only the `as const satisfies Schema` statement. This approach does come with a few limitations. The first is `stringUnion` and `numberUnion` schema default values are not constrained by the defined union choices, only the primitive type. We might fix this issue later, but for now, we prioritize this over the case when `default` extends union choice by its definition.
 
 A second limitation is the depth of the compound schema data structure. Currently, we support 7 layers of depth. It's easy to increase this number, but because of the exponential nature of stored type variants in memory, we want to determine how much RAM each next layer will use before increasing it.
 
@@ -24,11 +22,13 @@ It's crucial to separate parsing/validation logic from the schema itself. Librar
 
 ## Cons
 
+- The library is not ready for production yet, the version is 0 and public API might be changed
 - Currently we support only 7 layers of compound structure depth but most likely it will be higher soon
 - We do not support records, discriminated unions, object unions, array unions, intersections, functions, NaN, Infinity and other not JSON compatible structures
 - Null value is acceptable by the parser but will be treated as undefined and transformed to undefined
 - Null value is not acceptable by the validator
-- We only plan to support custom parser/normalizer integration logic.
+
+Check out [github issues](https://github.com/incerta/schematox/issues) of the project to know what we are planning to support soon.
 
 ## Installation
 
@@ -299,7 +299,7 @@ const staticArray = {
 const programmaticArray = array(string())
 ```
 
-## Validate/parse error shape
+## Validate/parse InvalidSubject error shape
 
 Nested schema example. Subject `0` is invalid, should be a `string`:
 
@@ -334,43 +334,41 @@ The `result.error` will be:
 ]
 ```
 
-## Parse/validate differences
+If the `error` is present it's always an array which has at least one entry. Each entry has the following properties:
 
-The parser provides a new object/primitive without references to the evaluated subject. This functionality is responsible for clearing the `array` schema result value from `undefined` optional schema values.
+- `code` – could be `INVALID_TYPE` if schema subject or schema default value is not satisfies schema type requirement. Another code `INVALID_RANGE` which is about `min/max` and `minLength/maxLength` schema requirements
+- `schema` – the particular chunk of the `schema` where invalid subject value is found
+- `subject` – the particular chunk of the validated subject where invalid value is found
+- `path` – the path to error subject chunk from the root of the evaluated subject. Strings is keys and numbers are the array indexes
 
-Moreover, the parser manages the `null` value as `undefined` and subsequently replaces it with `undefined`. It also swaps `optional` values with the `default` value, provided that the default values are explicitly stated in the schema.
+## Parse/validate differences
 
-Particularly for this last function, the parser uses a separate type inference flow. This flow is accessible for the library user via the type generic `XParsed<T extends Schema>`. By leveraging this mechanism, the user can simplify the process and enhance efficiency.
+The parser returns `data` as new object/primitive without references to the parsed subject. Parser manages the `null` value as `undefined` and subsequently replaces it with `undefined`. It also swaps `optional` values with the `default` value from schema. One can infer schema parsed subject type by using `XParsed<typeof schema>` generic.
 
-The validator operates by returning a reference to the original object, rather than applying any form of mutations to it. This is a significant feature because it disregards the schema’s default values.
+The validator on the other hand returns the evaluated subject itself and not applying any mutation/transformation to it. The validator should be used in exceptional cases when we known subject type but not sure that it actually correct. One can infer schema validated subject type by using `XValidated<typeof schema>` generic.
 
-Furthermore, the validator incorporates a type inference flow distinct from the parser's. Available for utilization through the type generic `XValidated<T extends Schema>`.
+So the difference between `XParsed` and `XValidated` is just about handling `default` schema value. `XParsed` narrows optional schema subject type with default value in the way that it will not be optional, because optional `undefined` and `null` values will be replaced by the `default`. `XValidated` just ignores `default` schema value.
 
-Examples of described differences:
+Examples:
 
 ```typescript
 const optionalStrX = x('string?')
 
-/* Parser treats `null` as `undefined` */
-
-expect(optionalStrX.parse(null).data).toBe(undefined)
-expect(optionalStrX.parse(null).error).toBe(undefined)
-
-/* Validator is not */
+/* Parser doesn't check subject type */
 
-// @ts-expect-error 'null' is not assignable to parameter of type 'string | undefined'
-expect(optionalStrX.validate(null).error).toStrictEqual([
+expect(optionalStrX.parse(0).error).toStrictEqual([
   {
     code: 'INVALID_TYPE',
     schema: 'string?',
-    subject: null,
+    subject: 0,
     path: [],
   },
 ])
 
-/* Parser doesn't check subject type */
+/* Validator does */
 
-expect(optionalStrX.parse(0).error).toStrictEqual([
+// @ts-expect-error 'number' is not 'string'
+expect(optionalStrX.validate(0).error).toStrictEqual([
   {
     code: 'INVALID_TYPE',
     schema: 'string?',
@@ -379,14 +377,19 @@ expect(optionalStrX.parse(0).error).toStrictEqual([
   },
 ])
 
-/* Validator does */
+/* Parser treats `null` as `undefined` */
 
-// @ts-expect-error 'number' is not assignable to parameter of type 'string'
-expect(optionalStrX.validate(0).error).toStrictEqual([
+expect(optionalStrX.parse(null).data).toBe(undefined)
+expect(optionalStrX.parse(null).error).toBe(undefined)
+
+/* Validator is not */
+
+// @ts-expect-error 'null' is not 'string | undefined'
+expect(optionalStrX.validate(null).error).toStrictEqual([
   {
     code: 'INVALID_TYPE',
     schema: 'string?',
-    subject: 0,
+    subject: null,
     path: [],
   },
 ])
@@ -402,17 +405,6 @@ expect(defaultedStrX.parse(undefined).data).toBe('y')
 
 expect(defaultedStrX.validate(undefined).data).toBe(undefined)
 
-/* Parser clears subject array from optional undefined */
-
-const arrX = x({ type: 'array', of: 'string?' })
-const subject = [undefined, 'y', undefined, 'z']
-
-expect(arrX.parse(subject).data).toStrictEqual(['y', 'z'])
-
-/* Validator keeps them */
-
-expect(arrX.validate(subject).data).toStrictEqual(subject)
-
 /* Parser returning new object */
 
 expect(arrX.parse(subject).data === subject).toBe(false)

package/dist/base-schema-parser.d.ts

@@ -1,5 +1,5 @@
 import type { EitherError } from './utils/fp';
 import type { BaseSchema, Con_Schema_SubjT_P } from './types/compound-schema-types';
-import type { BaseSchemaParseError } from './error';
+import type { InvalidSubject, ErrorPath } from './error';
 export type BaseSchemaSubjectType = string | number | boolean | undefined;
-export declare function parseBaseSchemaSubject<T extends BaseSchema>(schema: T, schemaSubject: unknown): EitherError<BaseSchemaParseError, Con_Schema_SubjT_P<T>>;
+export declare function parseBaseSchemaSubject<T extends BaseSchema>(this: ErrorPath | void, schema: T, schemaSubject: unknown): EitherError<InvalidSubject, Con_Schema_SubjT_P<T>>;

package/dist/base-schema-parser.js

@@ -15,7 +15,8 @@ function parseBaseSchemaSubject(schema, subject) {
                         }
                     }
                     return (0, fp_1.error)({
-                        code: error_1.PARSE_ERROR_CODE.invalidType,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -31,21 +32,16 @@ function parseBaseSchemaSubject(schema, subject) {
                         }
                     }
                     return (0, fp_1.error)({
-                        code: error_1.PARSE_ERROR_CODE.invalidType,
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                if (Number.isNaN(subject)) {
-                    return (0, fp_1.error)({
-                        code: error_1.PARSE_ERROR_CODE.NaN,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
                 }
                 if (Number.isFinite(subject) === false) {
                     return (0, fp_1.error)({
-                        code: error_1.PARSE_ERROR_CODE.infinity,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -61,7 +57,8 @@ function parseBaseSchemaSubject(schema, subject) {
                         }
                     }
                     return (0, fp_1.error)({
-                        code: error_1.PARSE_ERROR_CODE.invalidType,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -70,207 +67,138 @@ function parseBaseSchemaSubject(schema, subject) {
             }
         }
     }
+    var updatedSubject = typeof schema.default !== undefined &&
+        schema.optional &&
+        (subject === null || subject === undefined)
+        ? schema.default
+        : subject;
+    if (schema.optional) {
+        if (updatedSubject === null || updatedSubject === undefined) {
+            return (0, fp_1.data)(undefined);
+        }
+    }
     switch (schema.type) {
         case 'string': {
-            if (typeof subject !== 'string') {
-                if (subject === undefined || subject === null) {
-                    if (schema.optional) {
-                        if (typeof schema.default === 'string') {
-                            var rangeError_1 = getStringRangeError(schema, schema.default, true);
-                            if (rangeError_1) {
-                                return (0, fp_1.error)(rangeError_1);
-                            }
-                            return (0, fp_1.data)(schema.default);
-                        }
-                        return (0, fp_1.data)(undefined);
-                    }
-                }
+            if (typeof updatedSubject !== 'string') {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
-            var rangeError = getStringRangeError(schema, subject, false);
-            if (rangeError) {
-                return (0, fp_1.error)(rangeError);
+            if (typeof schema.minLength === 'number') {
+                if (updatedSubject.length < schema.minLength) {
+                    return (0, fp_1.error)({
+                        code: error_1.ERROR_CODE.invalidRange,
+                        subject: updatedSubject,
+                        path: this || [],
+                        schema: schema,
+                    });
+                }
+            }
+            if (typeof schema.maxLength === 'number') {
+                if (updatedSubject.length > schema.maxLength) {
+                    return (0, fp_1.error)({
+                        code: error_1.ERROR_CODE.invalidRange,
+                        subject: updatedSubject,
+                        path: this || [],
+                        schema: schema,
+                    });
+                }
             }
-            return (0, fp_1.data)(subject);
+            return (0, fp_1.data)(updatedSubject);
         }
         case 'number': {
-            if (typeof subject !== 'number') {
-                if (subject === undefined || subject === null) {
-                    if (schema.optional) {
-                        if (typeof schema.default === 'number') {
-                            var rangeError_2 = getNumberRangeError(schema, schema.default, true);
-                            if (rangeError_2) {
-                                return (0, fp_1.error)(rangeError_2);
-                            }
-                            return (0, fp_1.data)(schema.default);
-                        }
-                        return (0, fp_1.data)(undefined);
-                    }
-                }
+            if (typeof updatedSubject !== 'number') {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
-            if (Number.isNaN(subject)) {
+            if (Number.isFinite(updatedSubject) === false) {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.NaN,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
-            if (Number.isFinite(subject) === false) {
-                return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.infinity,
-                    schema: schema,
-                    subject: subject,
-                });
+            if (typeof schema.min === 'number') {
+                if (updatedSubject < schema.min) {
+                    return (0, fp_1.error)({
+                        code: error_1.ERROR_CODE.invalidRange,
+                        subject: updatedSubject,
+                        path: this || [],
+                        schema: schema,
+                    });
+                }
             }
-            var rangeError = getNumberRangeError(schema, subject, false);
-            if (rangeError) {
-                return (0, fp_1.error)(rangeError);
+            if (typeof schema.max === 'number') {
+                if (updatedSubject > schema.max) {
+                    return (0, fp_1.error)({
+                        code: error_1.ERROR_CODE.invalidRange,
+                        subject: updatedSubject,
+                        path: this || [],
+                        schema: schema,
+                    });
+                }
             }
-            return (0, fp_1.data)(subject);
+            return (0, fp_1.data)(updatedSubject);
         }
         case 'boolean': {
-            if (typeof subject !== 'boolean') {
-                if (subject === undefined || subject === null) {
-                    if (schema.optional) {
-                        if (typeof schema.default === 'boolean') {
-                            return (0, fp_1.data)(schema.default);
-                        }
-                        return (0, fp_1.data)(undefined);
-                    }
-                }
+            if (typeof updatedSubject !== 'boolean') {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
-            return (0, fp_1.data)(subject);
+            return (0, fp_1.data)(updatedSubject);
         }
         case 'stringUnion': {
-            if (typeof subject !== 'string') {
-                if (subject === undefined || subject === null) {
-                    if (schema.optional) {
-                        if (typeof schema.default === 'string') {
-                            var unionSet_1 = new Set(schema.of);
-                            if (unionSet_1.has(schema.default) === false) {
-                                return (0, fp_1.error)({
-                                    code: error_1.PARSE_ERROR_CODE.schemaDefaultNotInUnion,
-                                    subject: schema.default,
-                                    schema: schema,
-                                });
-                            }
-                            return (0, fp_1.data)(schema.default);
-                        }
-                        return (0, fp_1.data)(undefined);
-                    }
-                }
+            if (typeof updatedSubject !== 'string') {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
             var unionSet = new Set(schema.of);
-            if (unionSet.has(subject) === false) {
+            if (unionSet.has(updatedSubject) === false) {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.notInUnion,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
-            return (0, fp_1.data)(subject);
+            return (0, fp_1.data)(updatedSubject);
         }
         case 'numberUnion': {
-            if (typeof subject !== 'number') {
-                if (subject === undefined || subject === null) {
-                    if (schema.optional) {
-                        if (typeof schema.default === 'number') {
-                            var unionSet_2 = new Set(schema.of);
-                            if (unionSet_2.has(schema.default) === false) {
-                                return (0, fp_1.error)({
-                                    code: error_1.PARSE_ERROR_CODE.schemaDefaultNotInUnion,
-                                    subject: schema.default,
-                                    schema: schema,
-                                });
-                            }
-                            return (0, fp_1.data)(schema.default);
-                        }
-                        return (0, fp_1.data)(undefined);
-                    }
-                }
+            if (typeof updatedSubject !== 'number') {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
             var unionSet = new Set(schema.of);
-            if (unionSet.has(subject) === false) {
+            if (unionSet.has(updatedSubject) === false) {
                 return (0, fp_1.error)({
-                    code: error_1.PARSE_ERROR_CODE.notInUnion,
+                    code: error_1.ERROR_CODE.invalidType,
+                    subject: updatedSubject,
+                    path: this || [],
                     schema: schema,
-                    subject: subject,
                 });
             }
-            return (0, fp_1.data)(subject);
+            return (0, fp_1.data)(updatedSubject);
         }
     }
 }
 exports.parseBaseSchemaSubject = parseBaseSchemaSubject;
-function getStringRangeError(schema, subject, isSubjectFromSchemaDefault) {
-    if (typeof schema.minLength === 'number') {
-        if (subject.length < schema.minLength) {
-            return {
-                code: isSubjectFromSchemaDefault
-                    ? error_1.PARSE_ERROR_CODE.schemaDefaultMinRange
-                    : error_1.PARSE_ERROR_CODE.minRange,
-                schema: schema,
-                subject: subject,
-            };
-        }
-    }
-    if (typeof schema.maxLength === 'number') {
-        if (subject.length > schema.maxLength) {
-            return {
-                code: isSubjectFromSchemaDefault
-                    ? error_1.PARSE_ERROR_CODE.schemaDefaultMaxRange
-                    : error_1.PARSE_ERROR_CODE.maxRange,
-                schema: schema,
-                subject: subject,
-            };
-        }
-    }
-}
-function getNumberRangeError(schema, subject, isSubjectFromSchemaDefault) {
-    if (typeof schema.min === 'number') {
-        if (subject < schema.min) {
-            return {
-                code: isSubjectFromSchemaDefault
-                    ? error_1.PARSE_ERROR_CODE.schemaDefaultMinRange
-                    : error_1.PARSE_ERROR_CODE.minRange,
-                schema: schema,
-                subject: subject,
-            };
-        }
-    }
-    if (typeof schema.max === 'number') {
-        if (subject > schema.max) {
-            return {
-                code: isSubjectFromSchemaDefault
-                    ? error_1.PARSE_ERROR_CODE.schemaDefaultMaxRange
-                    : error_1.PARSE_ERROR_CODE.maxRange,
-                schema: schema,
-                subject: subject,
-            };
-        }
-    }
-}

package/dist/base-schema-validator.d.ts

@@ -1,5 +1,5 @@
 import type { EitherError } from './utils/fp';
 import type { BaseSchema, Con_Schema_SubjT_V } from './types/compound-schema-types';
-import type { BaseSchemaValidateError } from './error';
+import type { InvalidSubject, ErrorPath } from './error';
 export type BaseSchemaSubjectType = string | number | boolean | undefined;
-export declare function validateBaseSchemaSubject<T extends BaseSchema>(schema: T, schemaSubject: unknown): EitherError<BaseSchemaValidateError, Con_Schema_SubjT_V<T>>;
+export declare function validateBaseSchemaSubject<T extends BaseSchema>(this: ErrorPath | void, schema: T, schemaSubject: unknown): EitherError<InvalidSubject, Con_Schema_SubjT_V<T>>;

package/dist/base-schema-validator.js

@@ -13,7 +13,8 @@ function validateBaseSchemaSubject(schema, subject) {
                         return (0, fp_1.data)(undefined);
                     }
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -27,21 +28,16 @@ function validateBaseSchemaSubject(schema, subject) {
                         return (0, fp_1.data)(undefined);
                     }
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.invalidType,
-                        schema: schema,
-                        subject: subject,
-                    });
-                }
-                if (Number.isNaN(subject)) {
-                    return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.NaN,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
                 }
                 if (Number.isFinite(subject) === false) {
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.infinity,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -55,7 +51,8 @@ function validateBaseSchemaSubject(schema, subject) {
                         return (0, fp_1.data)(undefined);
                     }
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                        code: error_1.ERROR_CODE.invalidType,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -71,7 +68,8 @@ function validateBaseSchemaSubject(schema, subject) {
                     return (0, fp_1.data)(undefined);
                 }
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });
@@ -79,7 +77,8 @@ function validateBaseSchemaSubject(schema, subject) {
             if (typeof schema.minLength === 'number') {
                 if (subject.length < schema.minLength) {
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.minRange,
+                        code: error_1.ERROR_CODE.invalidRange,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -88,7 +87,8 @@ function validateBaseSchemaSubject(schema, subject) {
             if (typeof schema.maxLength === 'number') {
                 if (subject.length > schema.maxLength) {
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.maxRange,
+                        code: error_1.ERROR_CODE.invalidRange,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -102,21 +102,16 @@ function validateBaseSchemaSubject(schema, subject) {
                     return (0, fp_1.data)(undefined);
                 }
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.invalidType,
-                    schema: schema,
-                    subject: subject,
-                });
-            }
-            if (Number.isNaN(subject)) {
-                return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.NaN,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });
             }
             if (Number.isFinite(subject) === false) {
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.infinity,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });
@@ -124,7 +119,8 @@ function validateBaseSchemaSubject(schema, subject) {
             if (typeof schema.min === 'number') {
                 if (subject < schema.min) {
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.minRange,
+                        code: error_1.ERROR_CODE.invalidRange,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -133,7 +129,8 @@ function validateBaseSchemaSubject(schema, subject) {
             if (typeof schema.max === 'number') {
                 if (subject > schema.max) {
                     return (0, fp_1.error)({
-                        code: error_1.VALIDATE_ERROR_CODE.maxRange,
+                        code: error_1.ERROR_CODE.invalidRange,
+                        path: this || [],
                         schema: schema,
                         subject: subject,
                     });
@@ -147,7 +144,8 @@ function validateBaseSchemaSubject(schema, subject) {
                     return (0, fp_1.data)(undefined);
                 }
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });
@@ -160,7 +158,8 @@ function validateBaseSchemaSubject(schema, subject) {
                     return (0, fp_1.data)(undefined);
                 }
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });
@@ -168,7 +167,8 @@ function validateBaseSchemaSubject(schema, subject) {
             var unionSet = new Set(schema.of);
             if (unionSet.has(subject) === false) {
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.notInUnion,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });
@@ -181,7 +181,8 @@ function validateBaseSchemaSubject(schema, subject) {
                     return (0, fp_1.data)(undefined);
                 }
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });
@@ -189,7 +190,8 @@ function validateBaseSchemaSubject(schema, subject) {
             var unionSet = new Set(schema.of);
             if (unionSet.has(subject) === false) {
                 return (0, fp_1.error)({
-                    code: error_1.VALIDATE_ERROR_CODE.notInUnion,
+                    code: error_1.ERROR_CODE.invalidType,
+                    path: this || [],
                     schema: schema,
                     subject: subject,
                 });

package/dist/error.d.ts

@@ -1,45 +1,15 @@
-import type { Schema, BaseSchema } from './types/compound-schema-types';
-export type ParseErrorCode = (typeof PARSE_ERROR_CODE)[keyof typeof PARSE_ERROR_CODE];
-export type ValidateErrorCode = (typeof VALIDATE_ERROR_CODE)[keyof typeof VALIDATE_ERROR_CODE];
-export type BaseSchemaParseError = {
-    code: ParseErrorCode;
-    schema: BaseSchema;
-    subject: unknown;
-};
-export type BaseSchemaValidateError = {
-    code: ValidateErrorCode;
-    schema: BaseSchema;
-    subject: unknown;
-};
-export type ErrorPath = Array<string | number>;
-export type ParseError = {
-    path: ErrorPath;
+import type { Schema } from './types/compound-schema-types';
+export type ErrorCode = (typeof ERROR_CODE)[keyof typeof ERROR_CODE];
+export type InvalidSubject = {
+    code: ErrorCode;
     schema: Schema;
     subject: unknown;
-};
-export type ValidateError = {
     path: ErrorPath;
-    schema: Schema;
-    subject: unknown;
 };
-export declare const PARSE_ERROR_CODE: {
-    readonly invalidType: "INVALID_TYPE";
-    readonly NaN: "NOT_A_NUMBER";
-    readonly infinity: "INFINITY";
-    readonly minRange: "MIN_RANGE";
-    readonly maxRange: "MAX_RANGE";
-    readonly notInUnion: "NOT_IN_UNION";
-    readonly schemaDefaultMinRange: "SCHEMA_DEFAULT_MIN_RANGE";
-    readonly schemaDefaultMaxRange: "SCHEMA_DEFAULT_MAX_RANGE";
-    readonly schemaDefaultNotInUnion: "SCHEMA_DEFAULT_NOT_IN_UNION";
-};
-export declare const VALIDATE_ERROR_CODE: {
-    readonly invalidType: "INVALID_TYPE";
-    readonly NaN: "NOT_A_NUMBER";
-    readonly infinity: "INFINITY";
-    readonly minRange: "MIN_RANGE";
-    readonly maxRange: "MAX_RANGE";
-    readonly notInUnion: "NOT_IN_UNION";
+export type ErrorPath = Array<string | number>;
+export declare const ERROR_CODE: {
+    invalidType: string;
+    invalidRange: string;
 };
 export declare const PROGRAMMATICALLY_DEFINED_ERROR_MSG: {
     readonly optionalDefined: "Schema \"optional\" is already defined";

package/dist/error.js

@@ -1,24 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROGRAMMATICALLY_DEFINED_ERROR_MSG = exports.VALIDATE_ERROR_CODE = exports.PARSE_ERROR_CODE = void 0;
-exports.PARSE_ERROR_CODE = {
+exports.PROGRAMMATICALLY_DEFINED_ERROR_MSG = exports.ERROR_CODE = void 0;
+exports.ERROR_CODE = {
     invalidType: 'INVALID_TYPE',
-    NaN: 'NOT_A_NUMBER',
-    infinity: 'INFINITY',
-    minRange: 'MIN_RANGE',
-    maxRange: 'MAX_RANGE',
-    notInUnion: 'NOT_IN_UNION',
-    schemaDefaultMinRange: 'SCHEMA_DEFAULT_MIN_RANGE',
-    schemaDefaultMaxRange: 'SCHEMA_DEFAULT_MAX_RANGE',
-    schemaDefaultNotInUnion: 'SCHEMA_DEFAULT_NOT_IN_UNION',
-};
-exports.VALIDATE_ERROR_CODE = {
-    invalidType: 'INVALID_TYPE',
-    NaN: 'NOT_A_NUMBER',
-    infinity: 'INFINITY',
-    minRange: 'MIN_RANGE',
-    maxRange: 'MAX_RANGE',
-    notInUnion: 'NOT_IN_UNION',
+    invalidRange: 'INVALID_RANGE',
 };
 exports.PROGRAMMATICALLY_DEFINED_ERROR_MSG = {
     optionalDefined: 'Schema "optional" is already defined',

package/dist/general-schema-parser.d.ts

@@ -1,4 +1,4 @@
 import type { EitherError } from './utils/fp';
 import type { Schema, Con_Schema_SubjT_P } from './types/compound-schema-types';
-import type { ParseError } from './error';
-export declare function parse<T extends Schema>(schema: T, subject: unknown): EitherError<ParseError[], Con_Schema_SubjT_P<T>>;
+import type { InvalidSubject } from './error';
+export declare function parse<T extends Schema>(schema: T, subject: unknown): EitherError<InvalidSubject[], Con_Schema_SubjT_P<T>>;

package/dist/general-schema-parser.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -47,9 +36,9 @@ function parse(schema, subject) {
         schema.type === 'boolean' ||
         schema.type === 'stringUnion' ||
         schema.type === 'numberUnion') {
-        var parsed = (0, base_schema_parser_1.parseBaseSchemaSubject)(schema, subject);
+        var parsed = base_schema_parser_1.parseBaseSchemaSubject.bind(this)(schema, subject);
         if (parsed.error) {
-            return (0, fp_1.error)([__assign(__assign({}, parsed.error), { path: this || [] })]);
+            return (0, fp_1.error)([parsed.error]);
         }
         return parsed;
     }
@@ -65,7 +54,7 @@ function parse(schema, subject) {
             subject.constructor !== Object) {
             return (0, fp_1.error)([
                 {
-                    code: error_1.PARSE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
                     path: this || [],
                     schema: schema,
                     subject: subject,
@@ -96,7 +85,7 @@ function parse(schema, subject) {
         }
         return (0, fp_1.error)([
             {
-                code: error_1.PARSE_ERROR_CODE.invalidType,
+                code: error_1.ERROR_CODE.invalidType,
                 path: this || [],
                 subject: subject,
                 schema: schema,
@@ -112,13 +101,33 @@ function parse(schema, subject) {
             parsed.error.forEach(function (err) { return errors.push(err); });
             continue;
         }
-        if (parsed.data !== undefined) {
-            result.push(parsed.data);
-        }
+        result.push(parsed.data);
     }
     if (errors.length) {
         return (0, fp_1.error)(errors);
     }
+    if (typeof schema.minLength === 'number' &&
+        result.length < schema.minLength) {
+        return (0, fp_1.error)([
+            {
+                code: error_1.ERROR_CODE.invalidRange,
+                path: this || [],
+                subject: subject,
+                schema: schema,
+            },
+        ]);
+    }
+    if (typeof schema.maxLength === 'number' &&
+        result.length > schema.maxLength) {
+        return (0, fp_1.error)([
+            {
+                code: error_1.ERROR_CODE.invalidRange,
+                path: this || [],
+                subject: subject,
+                schema: schema,
+            },
+        ]);
+    }
     return (0, fp_1.data)(result);
 }
 exports.parse = parse;

package/dist/general-schema-validator.d.ts

@@ -1,4 +1,4 @@
 import type { EitherError } from './utils/fp';
 import type { Schema, Con_Schema_SubjT_V } from './types/compound-schema-types';
-import type { ValidateError } from './error';
-export declare function validate<T extends Schema>(schema: T, subject: Con_Schema_SubjT_V<T>): EitherError<ValidateError[], Con_Schema_SubjT_V<T>>;
+import type { InvalidSubject } from './error';
+export declare function validate<T extends Schema>(schema: T, subject: Con_Schema_SubjT_V<T>): EitherError<InvalidSubject[], Con_Schema_SubjT_V<T>>;

package/dist/general-schema-validator.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -47,9 +36,9 @@ function validate(schema, subject) {
         schema.type === 'boolean' ||
         schema.type === 'stringUnion' ||
         schema.type === 'numberUnion') {
-        var validated = (0, base_schema_validator_1.validateBaseSchemaSubject)(schema, subject);
+        var validated = base_schema_validator_1.validateBaseSchemaSubject.bind(this)(schema, subject);
         if (validated.error) {
-            return (0, fp_1.error)([__assign(__assign({}, validated.error), { path: this || [] })]);
+            return (0, fp_1.error)([validated.error]);
         }
         return (0, fp_1.data)(subject);
     }
@@ -63,7 +52,7 @@ function validate(schema, subject) {
             subject.constructor !== Object) {
             return (0, fp_1.error)([
                 {
-                    code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                    code: error_1.ERROR_CODE.invalidType,
                     path: this || [],
                     schema: schema,
                     subject: subject,
@@ -91,7 +80,7 @@ function validate(schema, subject) {
         }
         return (0, fp_1.error)([
             {
-                code: error_1.VALIDATE_ERROR_CODE.invalidType,
+                code: error_1.ERROR_CODE.invalidType,
                 path: this || [],
                 subject: subject,
                 schema: schema,
@@ -110,6 +99,28 @@ function validate(schema, subject) {
     if (errors.length) {
         return (0, fp_1.error)(errors);
     }
+    if (typeof schema.minLength === 'number' &&
+        subject.length < schema.minLength) {
+        return (0, fp_1.error)([
+            {
+                code: error_1.ERROR_CODE.invalidRange,
+                path: this || [],
+                subject: subject,
+                schema: schema,
+            },
+        ]);
+    }
+    if (typeof schema.maxLength === 'number' &&
+        subject.length > schema.maxLength) {
+        return (0, fp_1.error)([
+            {
+                code: error_1.ERROR_CODE.invalidRange,
+                path: this || [],
+                subject: subject,
+                schema: schema,
+            },
+        ]);
+    }
     return (0, fp_1.data)(subject);
 }
 exports.validate = validate;

package/dist/index.js

@@ -8,7 +8,7 @@
  * but only with a MINOR version update.
  **/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.x = exports.validate = exports.parse = exports.object = exports.array = exports.numberUnion = exports.stringUnion = exports.boolean = exports.number = exports.string = void 0;
+exports.data = exports.error = exports.isData = exports.isError = exports.x = exports.validate = exports.parse = exports.object = exports.array = exports.numberUnion = exports.stringUnion = exports.boolean = exports.number = exports.string = void 0;
 /* Programmatically base schema definition */
 var string_1 = require("./programmatic-schema/string");
 Object.defineProperty(exports, "string", { enumerable: true, get: function () { return string_1.string; } });
@@ -32,3 +32,8 @@ var general_schema_validator_1 = require("./general-schema-validator");
 Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return general_schema_validator_1.validate; } });
 var x_closure_1 = require("./x-closure");
 Object.defineProperty(exports, "x", { enumerable: true, get: function () { return x_closure_1.x; } });
+var fp_1 = require("./utils/fp");
+Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return fp_1.isError; } });
+Object.defineProperty(exports, "isData", { enumerable: true, get: function () { return fp_1.isData; } });
+Object.defineProperty(exports, "error", { enumerable: true, get: function () { return fp_1.error; } });
+Object.defineProperty(exports, "data", { enumerable: true, get: function () { return fp_1.data; } });

package/dist/index.ts

@@ -35,6 +35,12 @@ export { x } from './x-closure'
 /* Typings */
 
 export type { BaseSchema, Schema } from './types/compound-schema-types'
+export type { InvalidSubject } from './error'
+
+/* Utils */
+
+export type { EitherError } from './utils/fp'
+export { isError, isData, error, data } from './utils/fp'
 
 /* XParsed infers set optional default schema value as always present */
 export type XParsed<T extends { __schema: Schema } | Schema> = T extends {

package/dist/types/compound-schema-types.ts

@@ -14,6 +14,9 @@ type R<T> =
   | ({ type: 'array'; of: T } & ArrSchemaOptProps)
   | ({ type: 'object'; of: Record<string, T> } & ObjSchemaOptProps)
 
+/* 7 layers of compound schema nesting is allowed */
+type NestedSchema = R<R<R<R<R<R<BaseSchema>>>>>>
+
 /* ArraySchema */
 
 export type ArrSchemaOptProps = {
@@ -23,11 +26,10 @@ export type ArrSchemaOptProps = {
   maxLength?: number /* <= */
 }
 
-export type ArraySchema<T extends Schema = R<R<R<R<R<R<BaseSchema>>>>>>> =
-  ArrSchemaOptProps & {
-    type: 'array'
-    of: T
-  }
+export type ArraySchema<T extends Schema = NestedSchema> = ArrSchemaOptProps & {
+  type: 'array'
+  of: T
+}
 
 /* ObjectSchema */
 
@@ -36,7 +38,7 @@ export type ObjSchemaOptProps = {
   description?: string
 }
 
-export type ObjectSchema<T extends Schema = R<R<R<R<R<R<BaseSchema>>>>>>> =
+export type ObjectSchema<T extends Schema = NestedSchema> =
   ObjSchemaOptProps & {
     type: 'object'
     of: Record<string, T>
@@ -63,12 +65,6 @@ export type ExtWith_CompoundSchemaOptionality<
   U,
 > = T extends { optional: true } ? U | undefined : U
 
-// TODO: should work as expected only if we add `& {}`
-//        which is currently forbidden by our linter
-export type Prettify_ObjectSchema_SubjT<T> = {
-  [k in keyof T]: T[k]
-}
-
 /* Construct ArraySchema subject type */
 
 export type Con_ArraySchema_SubjT_P<T extends ArraySchema> =
@@ -76,11 +72,11 @@ export type Con_ArraySchema_SubjT_P<T extends ArraySchema> =
     T,
     T extends { of: infer U }
       ? U extends BaseSchema
-        ? Array<NonNullable<Con_BaseSchema_SubjT_P<U>>>
+        ? Array<Con_BaseSchema_SubjT_P<U>>
         : U extends ArraySchema
-          ? Array<NonNullable<Con_ArraySchema_SubjT_P<U>>>
+          ? Array<Con_ArraySchema_SubjT_P<U>>
           : U extends ObjectSchema
-            ? Array<NonNullable<Con_ObjectSchema_SubjT_P<U>>>
+            ? Array<Con_ObjectSchema_SubjT_P<U>>
             : never
       : never
   >

package/dist/x-closure.d.ts

@@ -3,6 +3,6 @@ export declare function x<T extends Schema>(schemaDefinition: T | {
     __schema: T;
 }): {
     __schema: T;
-    validate: (subject: Con_Schema_SubjT_V<T>) => import("./utils/fp").EitherError<import("./error").ValidateError[], Con_Schema_SubjT_V<T>>;
-    parse: <T_1 = unknown>(subject: T_1) => import("./utils/fp").EitherError<import("./error").ParseError[], import("./types/compound-schema-types").Con_Schema_SubjT_P<T>>;
+    validate: (subject: Con_Schema_SubjT_V<T>) => import(".").EitherError<import("./error").InvalidSubject[], Con_Schema_SubjT_V<T>>;
+    parse: <T_1 = unknown>(subject: T_1) => import(".").EitherError<import("./error").InvalidSubject[], import("./types/compound-schema-types").Con_Schema_SubjT_P<T>>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schematox",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Define JSON compatible schema statically/programmatically and parse/validate its subject with typesafety",
   "author": "Konstantin Mazur",
   "license": "MIT",