schematox 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Changelog
 
-## [0.3.0](https://github.com/incerta/schematox/compare/v0.2.0...v0.3.0) (2024-05-04)
+## [0.3.1](https://github.com/incerta/schematox/compare/v0.3.0...v0.3.1)
+
+### Bugfix
+
+- [`e3527df`](https://github.com/incerta/schematox/commit/e3527dfb46b73a4b6579e3d2aea58f3301aded9a) [#24](https://github.com/incerta/schematox/pull/25) Parser should preserve object optional key only if it is specified in source
+
+### Chore
+
+- [`7d98a81`](https://github.com/incerta/schematox/commit/7d98a81c2bc18280299365da32f8346d5b145560) Use "es2015" tsconfig target instead of outdated "es5"
+
+### Features
+
+- [`8bc2082`](https://github.com/incerta/schematox/commit/8bc208211457901f4f7246f00694f112d56f8d56) [#22](https://github.com/incerta/schematox/issues/22) Ensure optional properties in schemas reflect as optional in object context (@incerta)
+
+## [0.3.0](https://github.com/incerta/schematox/compare/v0.2.0...v0.3.0)
 
 ### Features
 

package/dist/parse.js

@@ -1,48 +1,11 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = void 0;
-var error_1 = require("./error");
-var fp_1 = require("./utils/fp");
-var verify_primitive_1 = require("./verify-primitive");
+const error_1 = require("./error");
+const fp_1 = require("./utils/fp");
+const verify_primitive_1 = require("./verify-primitive");
 function parse(schema, subject) {
-    var e_1, _a;
-    var errors = [];
+    const errors = [];
     if (schema.optional === true && subject === undefined) {
         return (0, fp_1.right)(undefined);
     }
@@ -57,18 +20,32 @@ function parse(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidType,
                     path: this || [],
-                    schema: schema,
-                    subject: subject,
+                    schema,
+                    subject,
                 },
             ]);
         }
-        var result = {};
-        for (var key in schema.of) {
-            var nestedSchema = schema.of[key];
-            var nestedValue = subject[key];
-            var parsed = parse.bind(__spreadArray(__spreadArray([], __read((this || [])), false), [key], false))(nestedSchema, nestedValue);
+        const result = {};
+        for (const key in schema.of) {
+            const narrowedSubj = subject;
+            const nestedSchema = schema.of[key];
+            if (Object.prototype.hasOwnProperty.call(narrowedSubj, key) === false) {
+                if (nestedSchema.optional !== true) {
+                    return (0, fp_1.left)([
+                        {
+                            code: error_1.ERROR_CODE.invalidType,
+                            path: [...(this || []), key],
+                            schema,
+                            subject,
+                        },
+                    ]);
+                }
+                continue;
+            }
+            const nestedValue = narrowedSubj[key];
+            const parsed = parse.bind([...(this || []), key])(nestedSchema, nestedValue);
             if (parsed.left) {
-                parsed.left.forEach(function (err) { return errors.push(err); });
+                parsed.left.forEach((err) => errors.push(err));
                 continue;
             }
             result[key] = parsed.right;
@@ -84,18 +61,18 @@ function parse(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidType,
                     path: this || [],
-                    subject: subject,
-                    schema: schema,
+                    subject,
+                    schema,
                 },
             ]);
         }
-        var result = [];
-        for (var i = 0; i < subject.length; i++) {
-            var nestedSchema = schema.of;
-            var nestedValue = subject[i];
-            var parsed = parse.bind(__spreadArray(__spreadArray([], __read((this || [])), false), [i], false))(nestedSchema, nestedValue);
+        const result = [];
+        for (let i = 0; i < subject.length; i++) {
+            const nestedSchema = schema.of;
+            const nestedValue = subject[i];
+            const parsed = parse.bind([...(this || []), i])(nestedSchema, nestedValue);
             if (parsed.left) {
-                parsed.left.forEach(function (err) { return errors.push(err); });
+                parsed.left.forEach((err) => errors.push(err));
                 continue;
             }
             result.push(parsed.right);
@@ -109,8 +86,8 @@ function parse(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidRange,
                     path: this || [],
-                    subject: subject,
-                    schema: schema,
+                    subject,
+                    schema,
                 },
             ]);
         }
@@ -120,40 +97,30 @@ function parse(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidRange,
                     path: this || [],
-                    subject: subject,
-                    schema: schema,
+                    subject,
+                    schema,
                 },
             ]);
         }
         return (0, fp_1.right)(result);
     }
     if (schema.type === 'union') {
-        try {
-            for (var _b = __values(schema.of), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var subSchema = _c.value;
-                var parsed = parse(subSchema, subject);
-                if (parsed.left === undefined) {
-                    return (0, fp_1.right)(parsed.right);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        for (const subSchema of schema.of) {
+            const parsed = parse(subSchema, subject);
+            if (parsed.left === undefined) {
+                return (0, fp_1.right)(parsed.right);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return (0, fp_1.left)([
             {
                 code: error_1.ERROR_CODE.invalidType,
                 path: this || [],
-                subject: subject,
-                schema: schema,
+                subject,
+                schema,
             },
         ]);
     }
-    var verified = (0, verify_primitive_1.verifyPrimitive)(schema, subject);
+    const verified = (0, verify_primitive_1.verifyPrimitive)(schema, subject);
     if (verified === true) {
         return (0, fp_1.right)(subject);
     }
@@ -161,8 +128,8 @@ function parse(schema, subject) {
         {
             code: verified,
             path: this || [],
-            subject: subject,
-            schema: schema,
+            subject,
+            schema,
         },
     ]);
 }

package/dist/struct.js

@@ -1,72 +1,40 @@
 "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 __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.union = exports.array = exports.object = exports.literal = exports.boolean = exports.number = exports.string = exports.makeStruct = void 0;
-var constants_1 = require("./constants");
-var validate_1 = require("./validate");
-var parse_1 = require("./parse");
+const constants_1 = require("./constants");
+const validate_1 = require("./validate");
+const parse_1 = require("./parse");
 function makeStruct(schema) {
-    var params = constants_1.PARAMS_BY_SCHEMA_TYPE[schema.type];
-    var result = {
+    const params = constants_1.PARAMS_BY_SCHEMA_TYPE[schema.type];
+    const result = {
         __schema: schema,
-        parse: function (subj) { return (0, parse_1.parse)(schema, subj); },
-        validate: function (subj) { return (0, validate_1.validate)(schema, subj); },
-        guard: function (subj) {
-            return (0, validate_1.validate)(schema, subj).left === undefined;
-        },
+        parse: (subj) => (0, parse_1.parse)(schema, subj),
+        validate: (subj) => (0, validate_1.validate)(schema, subj),
+        guard: (subj) => (0, validate_1.validate)(schema, subj).left === undefined,
     };
     if (params.has('optional')) {
-        result.optional = function () { return makeStruct(__assign(__assign({}, schema), { optional: true })); };
+        result.optional = () => makeStruct(Object.assign(Object.assign({}, schema), { optional: true }));
     }
     if (params.has('nullable')) {
-        result.nullable = function () { return makeStruct(__assign(__assign({}, schema), { nullable: true })); };
+        result.nullable = () => makeStruct(Object.assign(Object.assign({}, schema), { nullable: true }));
     }
     if (params.has('description')) {
-        result.description = function (description) {
-            return makeStruct(__assign(__assign({}, schema), { description: description }));
-        };
+        result.description = (description) => makeStruct(Object.assign(Object.assign({}, schema), { description }));
     }
     if (params.has('brand')) {
-        result.brand = function (key, value) {
-            return makeStruct(__assign(__assign({}, schema), { brand: [key, value] }));
-        };
+        result.brand = (key, value) => makeStruct(Object.assign(Object.assign({}, schema), { brand: [key, value] }));
     }
     if (params.has('min')) {
-        result.min = function (min) { return makeStruct(__assign(__assign({}, schema), { min: min })); };
+        result.min = (min) => makeStruct(Object.assign(Object.assign({}, schema), { min }));
     }
     if (params.has('max')) {
-        result.max = function (max) { return makeStruct(__assign(__assign({}, schema), { max: max })); };
+        result.max = (max) => makeStruct(Object.assign(Object.assign({}, schema), { max }));
     }
     if (params.has('minLength')) {
-        result.minLength = function (minLength) {
-            return makeStruct(__assign(__assign({}, schema), { minLength: minLength }));
-        };
+        result.minLength = (minLength) => makeStruct(Object.assign(Object.assign({}, schema), { minLength }));
     }
     if (params.has('maxLength')) {
-        result.maxLength = function (maxLength) {
-            return makeStruct(__assign(__assign({}, schema), { maxLength: maxLength }));
-        };
+        result.maxLength = (maxLength) => makeStruct(Object.assign(Object.assign({}, schema), { maxLength }));
     }
     return result;
 }
@@ -84,37 +52,26 @@ function boolean() {
 }
 exports.boolean = boolean;
 function literal(of) {
-    return makeStruct({ type: 'literal', of: of });
+    return makeStruct({ type: 'literal', of });
 }
 exports.literal = literal;
 function object(of) {
-    var schema = { type: 'object', of: {} };
-    for (var key in of) {
+    const schema = { type: 'object', of: {} };
+    for (const key in of) {
         schema.of[key] = of[key].__schema;
     }
     return makeStruct(schema);
 }
 exports.object = object;
 function array(of) {
-    var schema = { type: 'array', of: of.__schema };
+    const schema = { type: 'array', of: of.__schema };
     return makeStruct(schema);
 }
 exports.array = array;
 function union(of) {
-    var e_1, _a;
-    var schema = { type: 'union', of: [] };
-    try {
-        for (var of_1 = __values(of), of_1_1 = of_1.next(); !of_1_1.done; of_1_1 = of_1.next()) {
-            var subSchema = of_1_1.value;
-            schema.of.push(subSchema.__schema);
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (of_1_1 && !of_1_1.done && (_a = of_1.return)) _a.call(of_1);
-        }
-        finally { if (e_1) throw e_1.error; }
+    const schema = { type: 'union', of: [] };
+    for (const subSchema of of) {
+        schema.of.push(subSchema.__schema);
     }
     return makeStruct(schema);
 }

package/dist/utils/fp.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.right = exports.left = void 0;
-var left = function (value) { return ({ left: value }); };
+const left = (value) => ({ left: value });
 exports.left = left;
-var right = function (value) { return ({ right: value }); };
+const right = (value) => ({ right: value });
 exports.right = right;

package/dist/validate.js

@@ -1,48 +1,11 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guard = exports.validate = void 0;
-var fp_1 = require("./utils/fp");
-var error_1 = require("./error");
-var verify_primitive_1 = require("./verify-primitive");
+const fp_1 = require("./utils/fp");
+const error_1 = require("./error");
+const verify_primitive_1 = require("./verify-primitive");
 function validate(schema, subject) {
-    var e_1, _a;
-    var errors = [];
+    const errors = [];
     if (schema.optional === true && subject === undefined) {
         return (0, fp_1.right)(undefined);
     }
@@ -57,19 +20,19 @@ function validate(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidType,
                     path: this || [],
-                    schema: schema,
-                    subject: subject,
+                    schema,
+                    subject,
                 },
             ]);
         }
-        var subjectKeySet = new Set(Object.keys(subject));
-        for (var key in schema.of) {
+        const subjectKeySet = new Set(Object.keys(subject));
+        for (const key in schema.of) {
             subjectKeySet.delete(key);
-            var nestedValue = subject[key];
-            var nestedSchema = schema.of[key];
-            var validated = validate.bind(__spreadArray(__spreadArray([], __read((this || [])), false), [key], false))(nestedSchema, nestedValue);
+            const nestedValue = subject[key];
+            const nestedSchema = schema.of[key];
+            const validated = validate.bind([...(this || []), key])(nestedSchema, nestedValue);
             if (validated.left) {
-                validated.left.forEach(function (err) { return errors.push(err); });
+                validated.left.forEach((err) => errors.push(err));
                 continue;
             }
         }
@@ -79,8 +42,8 @@ function validate(schema, subject) {
         if (subjectKeySet.size !== 0) {
             errors.push({
                 code: error_1.ERROR_CODE.invalidType,
-                subject: subject,
-                schema: schema,
+                subject,
+                schema,
                 path: this || [],
             });
             return (0, fp_1.left)(errors);
@@ -93,17 +56,17 @@ function validate(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidType,
                     path: this || [],
-                    subject: subject,
-                    schema: schema,
+                    subject,
+                    schema,
                 },
             ]);
         }
-        for (var i = 0; i < subject.length; i++) {
-            var nestedSchema = schema.of;
-            var nestedValue = subject[i];
-            var validated = validate.bind(__spreadArray(__spreadArray([], __read((this || [])), false), [i], false))(nestedSchema, nestedValue);
+        for (let i = 0; i < subject.length; i++) {
+            const nestedSchema = schema.of;
+            const nestedValue = subject[i];
+            const validated = validate.bind([...(this || []), i])(nestedSchema, nestedValue);
             if (validated.left) {
-                validated.left.forEach(function (err) { return errors.push(err); });
+                validated.left.forEach((err) => errors.push(err));
                 continue;
             }
         }
@@ -116,8 +79,8 @@ function validate(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidRange,
                     path: this || [],
-                    subject: subject,
-                    schema: schema,
+                    subject,
+                    schema,
                 },
             ]);
         }
@@ -127,39 +90,29 @@ function validate(schema, subject) {
                 {
                     code: error_1.ERROR_CODE.invalidRange,
                     path: this || [],
-                    subject: subject,
-                    schema: schema,
+                    subject,
+                    schema,
                 },
             ]);
         }
         return (0, fp_1.right)(subject);
     }
     if (schema.type === 'union') {
-        try {
-            for (var _b = __values(schema.of), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var subSchema = _c.value;
-                if (validate(subSchema, subject).left === undefined) {
-                    return (0, fp_1.right)(subject);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        for (const subSchema of schema.of) {
+            if (validate(subSchema, subject).left === undefined) {
+                return (0, fp_1.right)(subject);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return (0, fp_1.left)([
             {
                 code: error_1.ERROR_CODE.invalidType,
                 path: this || [],
-                subject: subject,
-                schema: schema,
+                subject,
+                schema,
             },
         ]);
     }
-    var verified = (0, verify_primitive_1.verifyPrimitive)(schema, subject);
+    const verified = (0, verify_primitive_1.verifyPrimitive)(schema, subject);
     if (verified === true) {
         return (0, fp_1.right)(subject);
     }
@@ -167,8 +120,8 @@ function validate(schema, subject) {
         {
             code: verified,
             path: this || [],
-            subject: subject,
-            schema: schema,
+            subject,
+            schema,
         },
     ]);
 }

package/dist/verify-primitive.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyPrimitive = void 0;
-var error_1 = require("./error");
+const error_1 = require("./error");
 function verifyPrimitive(schema, subject) {
     if (schema.optional === true && subject === undefined) {
         return true;

package/package.json

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