@based/schema 3.2.0 → 4.1.1

package/dist/set/fields/array.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.array = void 0;
-const utils_1 = require("@saulx/utils");
-const error_1 = require("../../error");
-const collectOperation = (fromArgs, collected, value, makeNegative) => {
-    fromArgs.collect(value);
-    if (collected.length) {
-        const collect = fromArgs.root._opts.collect;
-        for (const args of collected) {
-            if (makeNegative) {
-                args.path[fromArgs.path.length] =
-                    args.path[fromArgs.path.length] - makeNegative;
-                collect(args);
-            }
-            else {
-                collect(args);
-            }
-        }
-    }
-};
-const parseArray = async (args, value, idx = 0) => {
-    const fromValue = Array.isArray(value) ? value : [value];
-    const q = [];
-    const arr = new Array(fromValue.length);
-    const collectNested = ['object', 'record', 'text'].includes(args.fieldSchema.values.type);
-    const collected = [];
-    for (let i = 0; i < fromValue.length; i++) {
-        q.push(args.parse({
-            key: i + idx,
-            value: fromValue[i],
-            fieldSchema: args.fieldSchema.values,
-            collect: (nArgs) => {
-                const p = nArgs.path.slice(args.path.length);
-                // @ts-ignore
-                p[0] = p[0] - idx;
-                (0, utils_1.setByPath)(arr, p, nArgs.value);
-                if (collectNested) {
-                    collected.push(nArgs);
-                }
-            },
-        }));
-    }
-    await Promise.all(q);
-    return { arr, collected };
-};
-const operations = {
-    $insert: async (args, value) => {
-        if (typeof value.$insert.$idx !== 'number') {
-            args.error(error_1.ParseError.incorrectFormat);
-            return;
-        }
-        const { collected, arr } = await parseArray(args, value.$insert.$value, value.$insert.$idx);
-        value.$insert.$value = arr;
-        collectOperation(args, collected, value);
-    },
-    $push: async (args, value) => {
-        const { collected, arr } = await parseArray(args, value.$push.$value ?? value.$push);
-        value.$push = arr;
-        collectOperation(args, collected, value, arr.length);
-    },
-    $unshift: async (args, value) => {
-        const { collected, arr } = await parseArray(args, value.$unshift.$value ?? value.$unshift);
-        value.$unshift = arr;
-        collectOperation(args, collected, value);
-    },
-    $remove: async (args, value) => {
-        if (typeof value.$remove.$idx !== 'number') {
-            args.error(error_1.ParseError.incorrectFormat);
-            return;
-        }
-        args.collect(value);
-    },
-    $assign: async (args, value) => {
-        if (typeof value.$assign !== 'object' ||
-            typeof value.$assign.$idx !== 'number') {
-            args.error(error_1.ParseError.incorrectFormat);
-            return;
-        }
-        await args.parse({
-            key: value.$assign.$idx,
-            value: value.$assign.$value,
-            fieldSchema: args.fieldSchema.values,
-        });
-    },
-};
-const array = async (args) => {
-    args.stop();
-    if (typeof args.value !== 'object') {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    let value = '$value' in args.value ? args.value.$value : args.value;
-    if (Array.isArray(value)) {
-        const q = [];
-        args.collect({ $delete: true });
-        for (let i = 0; i < value.length; i++) {
-            q.push(args.parse({
-                key: i,
-                value: args.value[i],
-                fieldSchema: args.fieldSchema.values,
-            }));
-        }
-        await Promise.all(q);
-        return;
-    }
-    let hasOperation = false;
-    for (const key in value) {
-        if (operations[key]) {
-            if (hasOperation) {
-                args.error(error_1.ParseError.multipleOperationsNotAllowed);
-                return;
-            }
-            await operations[key](args, value);
-            hasOperation = true;
-        }
-        else {
-            args.error(error_1.ParseError.fieldDoesNotExist);
-        }
-    }
-};
-exports.array = array;
-//# sourceMappingURL=array.js.map

package/dist/set/fields/index.d.ts

@@ -1,3 +0,0 @@
-import { FieldParsers } from '../../walker';
-import { BasedSetTarget } from '../../types';
-export declare const fields: Partial<FieldParsers<BasedSetTarget>>;

package/dist/set/fields/index.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fields = void 0;
-const error_1 = require("../../error");
-const array_1 = require("./array");
-const object_1 = require("./object");
-const number_1 = require("./number");
-const string_1 = require("./string");
-const references_1 = require("./references");
-const set_1 = require("./set");
-const hash_1 = require("@saulx/hash");
-const utils_1 = require("@saulx/utils");
-exports.fields = {
-    array: array_1.array,
-    object: object_1.object,
-    record: object_1.record,
-    number: number_1.number,
-    integer: number_1.integer,
-    timestamp: number_1.timestamp,
-    string: string_1.string,
-    set: set_1.set,
-    text: string_1.text,
-    reference: references_1.reference,
-    references: references_1.references,
-    cardinality: async (args) => {
-        let hashedValue;
-        if (args.value && typeof args.value === 'object') {
-            args.stop();
-            if (args.value.$default !== undefined) {
-                args.error(error_1.ParseError.defaultNotSupported);
-                return;
-            }
-            if (args.value.$value !== undefined) {
-                hashedValue = (0, hash_1.hashObjectIgnoreKeyOrder)(args.value.$value).toString(16);
-            }
-            else {
-                hashedValue = (0, hash_1.hashObjectIgnoreKeyOrder)(args.value).toString(16);
-            }
-        }
-        else {
-            hashedValue = (0, hash_1.hash)(args.value).toString(16);
-        }
-        args.collect(hashedValue);
-    },
-    boolean: async (args) => {
-        if (typeof args.value !== 'boolean') {
-            args.error(error_1.ParseError.incorrectFormat);
-            return;
-        }
-        args.collect();
-    },
-    json: async (args) => {
-        args.stop();
-        try {
-            const parsedValue = JSON.stringify(args.value);
-            args.collect(parsedValue);
-        }
-        catch (err) {
-            args.error(error_1.ParseError.invalidJSON);
-        }
-    },
-    enum: async (args) => {
-        // args.stop()
-        const enumValues = args.fieldSchema.enum;
-        for (let i = 0; i < enumValues.length; i++) {
-            if ((0, utils_1.deepEqual)(enumValues[i], args.value)) {
-                args.collect(i);
-                return;
-            }
-        }
-        args.error(error_1.ParseError.incorrectFormat);
-    },
-};
-//# sourceMappingURL=index.js.map

package/dist/set/fields/number.d.ts

@@ -1,4 +0,0 @@
-import { FieldParser } from '../../walker';
-export declare const number: FieldParser<'number'>;
-export declare const integer: FieldParser<'integer'>;
-export declare const timestamp: FieldParser<'timestamp'>;

package/dist/set/fields/number.js

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.timestamp = exports.integer = exports.number = void 0;
-const error_1 = require("../../error");
-const validateNumber = (args, value, ignoreMinMax) => {
-    const { fieldSchema } = args;
-    if (typeof value !== 'number') {
-        args.error(error_1.ParseError.incorrectFormat);
-        return false;
-    }
-    if (isNaN(value)) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return false;
-    }
-    if (value === Infinity || value === -Infinity) {
-        args.error(error_1.ParseError.infinityNotSupported);
-        return false;
-    }
-    if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return false;
-    }
-    if (fieldSchema.multipleOf &&
-        value / fieldSchema.multipleOf -
-            Math.floor(value / fieldSchema.multipleOf) !==
-            0) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return false;
-    }
-    if (ignoreMinMax) {
-        // TODO: will be handled in the actual modify command
-        return true;
-    }
-    if (fieldSchema.maximum) {
-        if (fieldSchema.exclusiveMaximum) {
-            if (value >= fieldSchema.maximum) {
-                args.error(error_1.ParseError.exceedsMaximum);
-                return false;
-            }
-        }
-        else if (value > fieldSchema.maximum) {
-            args.error(error_1.ParseError.exceedsMaximum);
-            return false;
-        }
-    }
-    if (fieldSchema.minimum) {
-        if (fieldSchema.exclusiveMinimum) {
-            if (value <= fieldSchema.minimum) {
-                args.error(error_1.ParseError.subceedsMinimum);
-                return false;
-            }
-        }
-        else if (value < fieldSchema.minimum) {
-            args.error(error_1.ParseError.subceedsMinimum);
-            return false;
-        }
-    }
-    return true;
-};
-const validate = (args, value) => {
-    if (value === null) {
-        return false;
-    }
-    if (typeof value !== 'object') {
-        return validateNumber(args, value);
-    }
-    if ('$value' in value) {
-        return;
-    }
-    args.stop();
-    for (const key in value) {
-        if (key === '$default') {
-            if (!validateNumber(args, value.$default)) {
-                return false;
-            }
-        }
-        else if (key === '$increment') {
-            if (!validateNumber(args, value.$increment, true)) {
-                return false;
-            }
-        }
-        else if (key === '$decrement') {
-            if (!validateNumber(args, value.$decrement, true)) {
-                return false;
-            }
-        }
-        else {
-            args.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
-            return false;
-        }
-    }
-    return true;
-};
-const number = async (args) => {
-    if (!validate(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-exports.number = number;
-const integer = async (args) => {
-    if (!validate(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-exports.integer = integer;
-const timestamp = async (args) => {
-    if (typeof args.value === 'string') {
-        if (args.value === 'now') {
-            // TODO: + 1s + 10s etc
-            args.value = Date.now();
-        }
-        else {
-            const d = new Date(args.value);
-            args.value = d.valueOf();
-            if (isNaN(args.value)) {
-                args.error(error_1.ParseError.incorrectFormat);
-                return;
-            }
-        }
-    }
-    if (!validateNumber(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-exports.timestamp = timestamp;
-//# sourceMappingURL=number.js.map

package/dist/set/fields/object.d.ts

@@ -1,3 +0,0 @@
-import { FieldParser } from '../../walker';
-export declare const object: FieldParser<'object'>;
-export declare const record: FieldParser<'record'>;

package/dist/set/fields/object.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.record = exports.object = void 0;
-const error_1 = require("../../error");
-const object = async (args) => {
-    if (typeof args.value !== 'object' || args.value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    const isArray = Array.isArray(args.value);
-    if (isArray) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    args.collect();
-    return args;
-};
-exports.object = object;
-const record = async (args) => {
-    if (typeof args.value !== 'object' || args.value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    const isArray = Array.isArray(args.value);
-    if (isArray) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    args.collect();
-    return args;
-};
-exports.record = record;
-//# sourceMappingURL=object.js.map

package/dist/set/fields/references.d.ts

@@ -1,3 +0,0 @@
-import { FieldParser } from '../../walker';
-export declare const reference: FieldParser<'reference'>;
-export declare const references: FieldParser<'references'>;

package/dist/set/fields/references.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.references = exports.reference = void 0;
-const error_1 = require("../../error");
-const isValidId_1 = require("../isValidId");
-async function parseOperator(args, key) {
-    if (Array.isArray(args.value[key])) {
-        const n = args.create({
-            key,
-            skipCollection: true,
-            value: args.value[key],
-        });
-        await n.parse();
-        if (n.value?.$value) {
-            return n.value.$value;
-        }
-        return [];
-    }
-    const n = args.create({
-        value: args.value[key],
-        key,
-        skipCollection: true,
-    });
-    await (0, exports.reference)(n);
-    return [n.value];
-}
-const typeIsAllowed = (args, type) => {
-    if ('allowedTypes' in args.fieldSchema) {
-        let typeMatches = false;
-        for (const t of args.fieldSchema.allowedTypes) {
-            if (typeof t === 'string') {
-                if (t === type) {
-                    return true;
-                }
-            }
-            else {
-                if (t.type && t.type === type) {
-                    typeMatches = true;
-                    if (t.$filter) {
-                        // stage on requires validation in target
-                        // TODO: ASYNC REQUIRED HOOK
-                        // if(!(await args.target.referenceFilterCondition(value, t.$filter))){
-                        //     error(args, ParseError.referenceIsIncorrectType)
-                        //     return
-                        // }
-                    }
-                }
-                else if (!t.type && t.$filter) {
-                    // if(!(await args.target.referenceFilterCondition))
-                    // error(args, ParseError.referenceIsIncorrectType, )
-                    // return
-                }
-            }
-        }
-        if (typeMatches === false) {
-            return false;
-        }
-    }
-    return true;
-};
-const reference = async (args) => {
-    // TODO: setting an object here , handling $alias (both async hooks)
-    // Block if path contains $remove (maybe not for $alias)
-    if (typeof args.value === 'object') {
-        if (args.root._opts.asyncOperationHandler) {
-            if (args.value.type && !typeIsAllowed(args, args.value.type)) {
-                args.error(error_1.ParseError.referenceIsIncorrectType);
-                return;
-            }
-            if (!args.target.errors.length) {
-                args.value = await args.root._opts.asyncOperationHandler(args, 'modifyObject');
-            }
-        }
-        else {
-            args.error(error_1.ParseError.nestedModifyObjectNotAllowed);
-            return;
-        }
-    }
-    if (!(0, isValidId_1.isValidId)(args.schema, args.value)) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    const prefix = args.value.slice(0, 2);
-    const targetType = args.schema.prefixToTypeMapping[prefix];
-    if (typeIsAllowed(args, targetType)) {
-        args.collect();
-    }
-    else {
-        args.error(error_1.ParseError.referenceIsIncorrectType);
-    }
-};
-exports.reference = reference;
-const references = async (args) => {
-    const { value } = args;
-    if (typeof value !== 'object' || value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    args.stop();
-    if (Array.isArray(value)) {
-        const parseValues = await Promise.all(value.map(async (id, key) => {
-            const n = args.create({
-                value: id,
-                key,
-                skipCollection: true,
-            });
-            await (0, exports.reference)(n);
-            return n.value;
-        }));
-        args.value = { $value: parseValues };
-    }
-    else {
-        for (const key in args.value) {
-            if (key === '$add') {
-                args.value.$add = await parseOperator(args, key);
-            }
-            else if (key === '$remove') {
-                args.value.$remove = await parseOperator(args, key);
-            }
-            else {
-                args.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
-            }
-        }
-    }
-    args.collect();
-};
-exports.references = references;
-//# sourceMappingURL=references.js.map

package/dist/set/fields/set.d.ts

@@ -1,2 +0,0 @@
-import { FieldParser } from '../../walker';
-export declare const set: FieldParser<'set'>;

package/dist/set/fields/set.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.set = void 0;
-const error_1 = require("../../error");
-async function parseOperator(args, key) {
-    if (Array.isArray(args.value[key])) {
-        const n = args.create({
-            key,
-            skipCollection: true,
-            value: args.value[key],
-        });
-        await n.parse();
-        if (n.value?.$value) {
-            return n.value.$value;
-        }
-        return [];
-    }
-    const n = args.create({
-        key,
-        skipCollection: true,
-        value: args.value[key],
-        fieldSchema: args.fieldSchema.items,
-    });
-    await n.parse();
-    return [n.value];
-}
-const set = async (args) => {
-    if (typeof args.value !== 'object' || args.value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    args.stop();
-    const isArray = Array.isArray(args.value);
-    if (isArray) {
-        const newArgs = [];
-        for (let i = 0; i < args.value.length; i++) {
-            newArgs.push(args.create({
-                key: i,
-                value: args.value[i],
-                fieldSchema: args.fieldSchema.items,
-                skipCollection: true,
-            }));
-        }
-        await Promise.all(newArgs.map((args) => args.parse()));
-        args.value = { $value: newArgs.map((args) => args.value) };
-    }
-    else {
-        for (const key in args.value) {
-            if (key === '$add') {
-                args.value.$add = await parseOperator(args, key);
-            }
-            else if (key === '$remove') {
-                args.value.$remove = await parseOperator(args, key);
-            }
-            else {
-                args.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
-            }
-        }
-    }
-    args.collect();
-};
-exports.set = set;
-//# sourceMappingURL=set.js.map

package/dist/set/fields/string.d.ts

@@ -1,3 +0,0 @@
-import { FieldParser } from '../../walker';
-export declare const string: FieldParser<'string'>;
-export declare const text: FieldParser<'text'>;