@based/schema 4.1.1 → 5.0.0-alpha.1

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

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

package/dist/src/set/fields/set.js

@@ -1,59 +0,0 @@
-import { ParseError } from '../../error.js';
-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];
-}
-export const set = async (args) => {
-    if (typeof args.value !== 'object' || args.value === null) {
-        args.error(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(ParseError.fieldDoesNotExist);
-            }
-        }
-    }
-    args.collect();
-};
-//# sourceMappingURL=set.js.map

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

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

package/dist/src/set/fields/string.js

@@ -1,289 +0,0 @@
-import { ParseError } from '../../error.js';
-import validators from 'validator';
-const formatPatterns = {
-    email: validators.isEmail,
-    URL: validators.isURL,
-    MACAddress: validators.isMACAddress,
-    IP: validators.isIP,
-    IPRange: validators.isIPRange,
-    FQDN: validators.isFQDN,
-    IBAN: validators.isIBAN,
-    BIC: validators.isBIC,
-    alpha: validators.isAlpha,
-    alphaLocales: validators.isAlphaLocales,
-    alphanumeric: validators.isAlphanumeric,
-    alphanumericLocales: validators.isAlphanumericLocales,
-    passportNumber: validators.isPassportNumber,
-    port: validators.isPort,
-    lowercase: validators.isLowercase,
-    uppercase: validators.isUppercase,
-    ascii: validators.isAscii,
-    semVer: validators.isSemVer,
-    surrogatePair: validators.isSurrogatePair,
-    IMEI: validators.isIMEI,
-    hexadecimal: validators.isHexadecimal,
-    octal: validators.isOctal,
-    hexColor: validators.isHexColor,
-    rgbColor: validators.isRgbColor,
-    HSL: validators.isHSL,
-    ISRC: validators.isISRC,
-    MD5: validators.isMD5,
-    JWT: validators.isJWT,
-    UUID: validators.isUUID,
-    luhnNumber: validators.isLuhnNumber,
-    creditCard: validators.isCreditCard,
-    identityCard: validators.isIdentityCard,
-    EAN: validators.isEAN,
-    ISIN: validators.isISIN,
-    ISBN: validators.isISBN,
-    ISSN: validators.isISSN,
-    mobilePhone: validators.isMobilePhone,
-    mobilePhoneLocales: validators.isMobilePhoneLocales,
-    postalCode: validators.isPostalCode,
-    postalCodeLocales: validators.isPostalCodeLocales,
-    ethereumAddress: validators.isEthereumAddress,
-    currency: validators.isCurrency,
-    btcAddress: validators.isBtcAddress,
-    ISO6391: validators.isISO6391,
-    ISO8601: validators.isISO8601,
-    RFC3339: validators.isRFC3339,
-    ISO31661Alpha2: validators.isISO31661Alpha2,
-    ISO31661Alpha3: validators.isISO31661Alpha3,
-    ISO4217: validators.isISO4217,
-    base32: validators.isBase32,
-    base58: validators.isBase58,
-    base64: validators.isBase64,
-    dataURI: validators.isDataURI,
-    magnetURI: validators.isMagnetURI,
-    mimeType: validators.isMimeType,
-    latLong: validators.isLatLong,
-    slug: validators.isSlug,
-    strongPassword: validators.isStrongPassword,
-    taxID: validators.isTaxID,
-    licensePlate: validators.isLicensePlate,
-    VAT: validators.isVAT,
-    code: () => true,
-    javascript: () => true,
-    typescript: () => true,
-    python: () => true,
-    rust: () => true,
-    css: () => true,
-    html: () => true,
-    json: () => true,
-    markdown: () => true,
-    clike: () => true,
-    // Can add some more checks for this...
-    basedId: (value) => typeof value === 'string' && value.length < 16,
-    basedType: (value) => typeof value === 'string' && value.length < 64,
-};
-const validateString = (args, value) => {
-    if (typeof value !== 'string') {
-        args.error(ParseError.incorrectFormat);
-        return false;
-    }
-    if (args.fieldSchema.minLength && value.length < args.fieldSchema.minLength) {
-        args.error(ParseError.subceedsMinimum);
-        return false;
-    }
-    if (args.fieldSchema.maxLength && value.length > args.fieldSchema.maxLength) {
-        args.error(ParseError.exceedsMaximum);
-        return false;
-    }
-    if (args.fieldSchema.pattern) {
-        const re = new RegExp(args.fieldSchema.pattern);
-        if (!re.test(value)) {
-            args.error(ParseError.incorrectFormat);
-            return false;
-        }
-    }
-    if (args.fieldSchema.format &&
-        !formatPatterns[args.fieldSchema.format](value)) {
-        args.error(ParseError.incorrectFormat);
-        return false;
-    }
-    return true;
-};
-export const string = async (args) => {
-    if (!validateString(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-// --- bla
-// if typeof === string
-export const text = async (args) => {
-    const value = args.value;
-    args.stop();
-    if (value === null) {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    if (typeof value === 'object') {
-        for (const key in value) {
-            if (key === '$merge') {
-                if (typeof value.$merge !== 'boolean') {
-                    args.error(ParseError.incorrectFormat);
-                    return;
-                }
-            }
-            else if (key === '$delete') {
-                if (value[key] !== true) {
-                    args.error(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(ParseError.incorrectFormat);
-                    return;
-                }
-                if (typeof value[key] === 'object') {
-                    for (const k in value[key]) {
-                        if (!validateString(args, args.value[key][k])) {
-                            args.error(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(ParseError.incorrectFormat);
-                    return;
-                }
-                else if (!args.target.$language) {
-                    args.error(ParseError.noLanguageFound);
-                    return;
-                }
-                else if (!validateString(args, value[key])) {
-                    args.error(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(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(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(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(ParseError.fieldDoesNotExist);
-                            return;
-                        }
-                    }
-                }
-                else {
-                    if (!validateString(args, args.value[key])) {
-                        args.error(ParseError.incorrectFormat);
-                        return;
-                    }
-                    args
-                        .create({
-                        key,
-                        fieldSchema: { type: 'string' },
-                        value: args.value[key],
-                    })
-                        .collect();
-                }
-            }
-            else {
-                args.create({ key }).error(ParseError.languageNotSupported);
-            }
-        }
-        if (!args._stopObject) {
-            args.collect();
-        }
-        return;
-    }
-    if (typeof value !== 'string') {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    if (!args.target.$language) {
-        args.error(ParseError.noLanguageFound);
-        return;
-    }
-    if (!validateString(args, args.value)) {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    args
-        .create({
-        value,
-        key: args.target.$language,
-        fieldSchema: { type: 'string' },
-    })
-        .collect();
-    if (!args._stopObject) {
-        args.collect({
-            [args.target.$language]: value,
-        });
-    }
-};
-//# sourceMappingURL=string.js.map

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

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

package/dist/src/set/index.js

@@ -1,205 +0,0 @@
-import { ParseError } from '../error.js';
-import { walk } from '../walker/index.js';
-import { fields } from './fields/index.js';
-import { isValidId } from './isValidId.js';
-const opts = {
-    parsers: {
-        keys: {
-            $delete: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (args.prev === args.root) {
-                    args.error(ParseError.cannotDeleteNodeFromModify);
-                    return;
-                }
-                if (args.value === true) {
-                    args.stop();
-                    args.prev.collect();
-                    args.prev.stop();
-                    return;
-                }
-            },
-            $alias: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (Array.isArray(args.value)) {
-                    for (const field of args.value) {
-                        if (typeof field !== 'string') {
-                            args.error(ParseError.incorrectFormat);
-                            return;
-                        }
-                    }
-                    return;
-                }
-                if (typeof args.value !== 'string') {
-                    args.error(ParseError.incorrectFormat);
-                }
-            },
-            $merge: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (typeof args.value !== 'boolean') {
-                    args.error(ParseError.incorrectFormat);
-                    return;
-                }
-                if (args.prev !== args.root) {
-                    args.prev.collect({ $delete: true });
-                }
-                return;
-            },
-            $id: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (!isValidId(args.schema, args.value)) {
-                    args.error(ParseError.incorrectFormat);
-                    return;
-                }
-            },
-            $language: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (!(args.schema.translations || [])
-                    .concat(args.schema.language)
-                    .includes(args.value)) {
-                    args.error(ParseError.languageNotSupported);
-                    return;
-                }
-            },
-            $value: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'text' ||
-                    type === 'set' ||
-                    type == 'references' ||
-                    type === 'json') {
-                    return;
-                }
-                args.prev.stop();
-                args.stop();
-                if (args.prev.value.$default) {
-                    args.error(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' ||
-                    type === 'json') {
-                    // 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(ParseError.fieldDoesNotExist);
-                    }
-                }
-            },
-        },
-        fields,
-        catch: async (args) => {
-            args.error(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(ParseError.incorrectFieldType, { target });
-                return { target };
-            }
-        }
-        else if (value.$alias) {
-            target.$alias = value.$alias;
-        }
-        if (value.type) {
-            if (type && value.type !== type) {
-                error(ParseError.incorrectNodeType, { target });
-                return { target };
-            }
-            type = value.type;
-        }
-        const typeSchema = type === 'root' ? schema.root : schema.types[type];
-        if (!typeSchema) {
-            error(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(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);
-    },
-};
-export const setWalker = (schema, value, asyncOperationHandler) => {
-    return walk(schema, opts, value, asyncOperationHandler);
-};
-//# sourceMappingURL=index.js.map

package/dist/src/set/isValidId.d.ts

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

package/dist/src/set/isValidId.js

@@ -1,17 +0,0 @@
-export 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;
-};
-//# sourceMappingURL=isValidId.js.map