@based/schema 3.2.0 → 4.1.1

package/dist/set/fields/string.js

@@ -1,284 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.text = exports.string = void 0;
-const error_1 = require("../../error");
-const validator_1 = __importDefault(require("validator"));
-const formatPatterns = {
-    email: validator_1.default.isEmail,
-    URL: validator_1.default.isURL,
-    MACAddress: validator_1.default.isMACAddress,
-    IP: validator_1.default.isIP,
-    IPRange: validator_1.default.isIPRange,
-    FQDN: validator_1.default.isFQDN,
-    IBAN: validator_1.default.isIBAN,
-    BIC: validator_1.default.isBIC,
-    alpha: validator_1.default.isAlpha,
-    alphaLocales: validator_1.default.isAlphaLocales,
-    alphanumeric: validator_1.default.isAlphanumeric,
-    alphanumericLocales: validator_1.default.isAlphanumericLocales,
-    passportNumber: validator_1.default.isPassportNumber,
-    port: validator_1.default.isPort,
-    lowercase: validator_1.default.isLowercase,
-    uppercase: validator_1.default.isUppercase,
-    ascii: validator_1.default.isAscii,
-    semVer: validator_1.default.isSemVer,
-    surrogatePair: validator_1.default.isSurrogatePair,
-    IMEI: validator_1.default.isIMEI,
-    hexadecimal: validator_1.default.isHexadecimal,
-    octal: validator_1.default.isOctal,
-    hexColor: validator_1.default.isHexColor,
-    rgbColor: validator_1.default.isRgbColor,
-    HSL: validator_1.default.isHSL,
-    ISRC: validator_1.default.isISRC,
-    MD5: validator_1.default.isMD5,
-    JWT: validator_1.default.isJWT,
-    UUID: validator_1.default.isUUID,
-    luhnNumber: validator_1.default.isLuhnNumber,
-    creditCard: validator_1.default.isCreditCard,
-    identityCard: validator_1.default.isIdentityCard,
-    EAN: validator_1.default.isEAN,
-    ISIN: validator_1.default.isISIN,
-    ISBN: validator_1.default.isISBN,
-    ISSN: validator_1.default.isISSN,
-    mobilePhone: validator_1.default.isMobilePhone,
-    mobilePhoneLocales: validator_1.default.isMobilePhoneLocales,
-    postalCode: validator_1.default.isPostalCode,
-    postalCodeLocales: validator_1.default.isPostalCodeLocales,
-    ethereumAddress: validator_1.default.isEthereumAddress,
-    currency: validator_1.default.isCurrency,
-    btcAddress: validator_1.default.isBtcAddress,
-    ISO6391: validator_1.default.isISO6391,
-    ISO8601: validator_1.default.isISO8601,
-    RFC3339: validator_1.default.isRFC3339,
-    ISO31661Alpha2: validator_1.default.isISO31661Alpha2,
-    ISO31661Alpha3: validator_1.default.isISO31661Alpha3,
-    ISO4217: validator_1.default.isISO4217,
-    base32: validator_1.default.isBase32,
-    base58: validator_1.default.isBase58,
-    base64: validator_1.default.isBase64,
-    dataURI: validator_1.default.isDataURI,
-    magnetURI: validator_1.default.isMagnetURI,
-    mimeType: validator_1.default.isMimeType,
-    latLong: validator_1.default.isLatLong,
-    slug: validator_1.default.isSlug,
-    strongPassword: validator_1.default.isStrongPassword,
-    taxID: validator_1.default.isTaxID,
-    licensePlate: validator_1.default.isLicensePlate,
-    VAT: validator_1.default.isVAT,
-};
-const validateString = (args, value) => {
-    if (typeof value !== 'string') {
-        args.error(error_1.ParseError.incorrectFormat);
-        return false;
-    }
-    if (args.fieldSchema.minLength && value.length < args.fieldSchema.minLength) {
-        args.error(error_1.ParseError.subceedsMinimum);
-        return false;
-    }
-    if (args.fieldSchema.maxLength && value.length > args.fieldSchema.maxLength) {
-        args.error(error_1.ParseError.exceedsMaximum);
-        return false;
-    }
-    if (args.fieldSchema.pattern) {
-        const re = new RegExp(args.fieldSchema.pattern);
-        if (!re.test(value)) {
-            args.error(error_1.ParseError.incorrectFormat);
-            return false;
-        }
-    }
-    if (args.fieldSchema.format &&
-        !formatPatterns[args.fieldSchema.format](value)) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return false;
-    }
-    return true;
-};
-const string = async (args) => {
-    if (!validateString(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-exports.string = string;
-// --- bla
-// if typeof === string
-const text = async (args) => {
-    const value = args.value;
-    args.stop();
-    if (value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    if (typeof value === 'object') {
-        for (const key in value) {
-            if (key === '$merge') {
-                if (typeof value.$merge !== 'boolean') {
-                    args.error(error_1.ParseError.incorrectFormat);
-                    return;
-                }
-            }
-            else if (key === '$delete') {
-                if (value[key] !== true) {
-                    args.error(error_1.ParseError.incorrectFormat);
-                    return;
-                }
-                args.collect({ $delete: true });
-                return;
-            }
-            else if (key === '$value') {
-                const valueArgs = args.create({
-                    path: args.path,
-                    value: args.value[key],
-                });
-                valueArgs._stopObject = true;
-                await valueArgs.parse();
-            }
-            else if (key === '$default') {
-                if (value[key] === null) {
-                    args.error(error_1.ParseError.incorrectFormat);
-                    return;
-                }
-                if (typeof value[key] === 'object') {
-                    for (const k in value[key]) {
-                        if (!validateString(args, args.value[key][k])) {
-                            args.error(error_1.ParseError.incorrectFormat);
-                            return;
-                        }
-                        args
-                            .create({
-                            key: k,
-                            fieldSchema: { type: 'string' },
-                            value: { $default: args.value[key][k] },
-                        })
-                            .collect();
-                    }
-                }
-                else if (typeof value[key] !== 'string') {
-                    args.error(error_1.ParseError.incorrectFormat);
-                    return;
-                }
-                else if (!args.target.$language) {
-                    args.error(error_1.ParseError.noLanguageFound);
-                    return;
-                }
-                else if (!validateString(args, value[key])) {
-                    args.error(error_1.ParseError.incorrectFormat);
-                    return;
-                }
-                else {
-                    args
-                        .create({
-                        fieldSchema: { type: 'string' },
-                        key: args.target.$language,
-                        value: { $default: args.value[key] },
-                    })
-                        .collect();
-                }
-            }
-            else if ((args.schema.translations || [])
-                .concat(args.schema.language)
-                .includes(key)) {
-                if (value[key] && typeof value[key] === 'object') {
-                    for (const k in value[key]) {
-                        if (k === '$delete') {
-                            if (value[key].$delete !== true) {
-                                args.error(error_1.ParseError.incorrectFormat);
-                                return;
-                            }
-                            args
-                                .create({
-                                key,
-                                fieldSchema: { type: 'string' },
-                                value: args.value[key],
-                            })
-                                .collect();
-                        }
-                        else if (k === '$value') {
-                            if (!validateString(args, value[key].$value)) {
-                                args.create({ key }).error(error_1.ParseError.incorrectFormat);
-                            }
-                            else {
-                                args
-                                    .create({
-                                    key,
-                                    fieldSchema: { type: 'string' },
-                                    value: args.value[key].$value,
-                                })
-                                    .collect();
-                            }
-                        }
-                        else if (k === '$default') {
-                            if (!validateString(args, value[key].$default)) {
-                                args.create({ key }).error(error_1.ParseError.incorrectFormat);
-                            }
-                            else {
-                                args
-                                    .create({
-                                    key,
-                                    fieldSchema: { type: 'string' },
-                                    value: { $default: args.value[key].$default },
-                                })
-                                    .collect();
-                            }
-                        }
-                        else {
-                            args
-                                .create({ path: [...args.path, key, k] })
-                                .error(error_1.ParseError.fieldDoesNotExist);
-                            return;
-                        }
-                    }
-                }
-                else {
-                    if (!validateString(args, args.value[key])) {
-                        args.error(error_1.ParseError.incorrectFormat);
-                        return;
-                    }
-                    args
-                        .create({
-                        key,
-                        fieldSchema: { type: 'string' },
-                        value: args.value[key],
-                    })
-                        .collect();
-                }
-            }
-            else {
-                args.create({ key }).error(error_1.ParseError.languageNotSupported);
-            }
-        }
-        if (!args._stopObject) {
-            args.collect();
-        }
-        return;
-    }
-    if (typeof value !== 'string') {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    if (!args.target.$language) {
-        args.error(error_1.ParseError.noLanguageFound);
-        return;
-    }
-    if (!validateString(args, args.value)) {
-        args.error(error_1.ParseError.incorrectFormat);
-        return;
-    }
-    args
-        .create({
-        value,
-        key: args.target.$language,
-        fieldSchema: { type: 'string' },
-    })
-        .collect();
-    if (!args._stopObject) {
-        args.collect({
-            [args.target.$language]: value,
-        });
-    }
-};
-exports.text = text;
-//# sourceMappingURL=string.js.map

package/dist/set/index.d.ts

@@ -1,3 +0,0 @@
-import { BasedSchema, BasedSetTarget } from '../types';
-import { AsyncOperation } from '../walker';
-export declare const setWalker: (schema: BasedSchema, value: any, asyncOperationHandler?: AsyncOperation<BasedSetTarget>) => Promise<BasedSetTarget>;

package/dist/set/index.js

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setWalker = void 0;
-const error_1 = require("../error");
-const walker_1 = require("../walker");
-const fields_1 = require("./fields");
-const isValidId_1 = require("./isValidId");
-const opts = {
-    parsers: {
-        keys: {
-            $delete: async (args) => {
-                if (args.prev === args.root) {
-                    args.error(error_1.ParseError.cannotDeleteNodeFromModify);
-                    return;
-                }
-                if (args.value === true) {
-                    args.stop();
-                    args.prev.collect();
-                    args.prev.stop();
-                    return;
-                }
-            },
-            $alias: async (args) => {
-                if (Array.isArray(args.value)) {
-                    for (const field of args.value) {
-                        if (typeof field !== 'string') {
-                            args.error(error_1.ParseError.incorrectFormat);
-                            return;
-                        }
-                    }
-                    return;
-                }
-                if (typeof args.value !== 'string') {
-                    args.error(error_1.ParseError.incorrectFormat);
-                }
-            },
-            $merge: async (args) => {
-                if (typeof args.value !== 'boolean') {
-                    args.error(error_1.ParseError.incorrectFormat);
-                    return;
-                }
-                if (args.prev !== args.root) {
-                    args.prev.collect({ $delete: true });
-                }
-                return;
-            },
-            $id: async (args) => {
-                if (!(0, isValidId_1.isValidId)(args.schema, args.value)) {
-                    args.error(error_1.ParseError.incorrectFormat);
-                    return;
-                }
-            },
-            $language: async (args) => {
-                if (!(args.schema.translations || [])
-                    .concat(args.schema.language)
-                    .includes(args.value)) {
-                    args.error(error_1.ParseError.languageNotSupported);
-                    return;
-                }
-            },
-            $value: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'text' || type === 'set' || type == 'references') {
-                    return;
-                }
-                args.prev.stop();
-                args.stop();
-                if (args.prev.value.$default) {
-                    args.error(error_1.ParseError.valueAndDefault);
-                    return;
-                }
-                return {
-                    path: args.path.slice(0, -1),
-                    value: args.value,
-                };
-            },
-            $default: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'number' || type === 'integer' || type === 'text') {
-                    // default can exist with $incr and $decr
-                    return;
-                }
-                args.prev.stop();
-                args.stop();
-                if (type === 'references' || type === 'set' || type === 'array') {
-                    const newArgs = args.create({
-                        path: args.path.slice(0, -1),
-                        skipCollection: true,
-                    });
-                    await newArgs.parse();
-                    newArgs.skipCollection = false;
-                    newArgs.value = { $default: newArgs.value };
-                    newArgs.collect();
-                }
-                else {
-                    const collect = args._collectOverride ?? args.root._opts.collect;
-                    const newArgs = args.create({
-                        path: args.path.slice(0, -1),
-                        collect: (a) => {
-                            if (a.path.length === args.path.length - 1) {
-                                collect(a.create({ value: { $default: a.value } }));
-                            }
-                            else {
-                                // console.info('hello', a.path) can handle this later
-                            }
-                        },
-                    });
-                    await newArgs.parse();
-                }
-                for (const key in args.prev.value) {
-                    if (key !== '$default') {
-                        args.prev.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
-                    }
-                }
-            },
-        },
-        fields: fields_1.fields,
-        catch: async (args) => {
-            args.error(error_1.ParseError.fieldDoesNotExist);
-        },
-    },
-    init: async (value, schema, error) => {
-        let type;
-        const target = {
-            type,
-            schema,
-            required: [],
-            collected: [],
-            errors: [],
-        };
-        if (value.$id) {
-            if (value.$id === 'root') {
-                type = 'root';
-            }
-            else {
-                type = schema.prefixToTypeMapping[value.$id.slice(0, 2)];
-            }
-            if (!type) {
-                error(error_1.ParseError.incorrectFieldType, { target });
-                return { target };
-            }
-        }
-        else if (value.$alias) {
-            target.$alias = value.$alias;
-        }
-        if (value.type) {
-            if (type && value.type !== type) {
-                error(error_1.ParseError.incorrectNodeType, { target });
-                return { target };
-            }
-            type = value.type;
-        }
-        const typeSchema = type === 'root' ? schema.root : schema.types[type];
-        if (!typeSchema) {
-            error(error_1.ParseError.incorrectNodeType, { target });
-            return { target };
-        }
-        target.type = type;
-        target.$language = value.$language;
-        target.$id = value.$id;
-        if ('$merge' in value) {
-            if (typeof value.$merge !== 'boolean') {
-                error(error_1.ParseError.incorrectFormat, { target });
-            }
-            target.$merge = value.$merge;
-        }
-        return { target, typeSchema };
-    },
-    error: (code, args) => {
-        args.target.errors.push({
-            code,
-            path: args.path ?? [],
-        });
-    },
-    collect: (args) => {
-        args.root.target.collected.push(args);
-    },
-};
-const setWalker = (schema, value, asyncOperationHandler) => {
-    return (0, walker_1.walk)(schema, opts, value, asyncOperationHandler);
-};
-exports.setWalker = setWalker;
-//# sourceMappingURL=index.js.map

package/dist/set/isValidId.d.ts

@@ -1,2 +0,0 @@
-import { BasedSchema } from '../types';
-export declare const isValidId: (schema: BasedSchema, id: any) => boolean;

package/dist/set/isValidId.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidId = void 0;
-const isValidId = (schema, id) => {
-    if (typeof id !== 'string') {
-        return false;
-    }
-    if (id === 'root') {
-        return true;
-    }
-    if (id.length > 16) {
-        return false;
-    }
-    const prefix = id.slice(0, 2);
-    if (!schema.prefixToTypeMapping[prefix]) {
-        return false;
-    }
-    return true;
-};
-exports.isValidId = isValidId;
-//# sourceMappingURL=isValidId.js.map

package/dist/set/types.js

@@ -1 +0,0 @@
-//# sourceMappingURL=types.js.map

package/dist/src/compat/newToOld.d.ts

@@ -1,3 +0,0 @@
-import { BasedOldSchema } from './oldSchemaType.js';
-import { BasedSchemaPartial } from '../types.js';
-export declare const convertNewToOld: (schema: BasedSchemaPartial) => Partial<BasedOldSchema>;