@based/schema 4.1.1 → 5.0.0-alpha.0

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

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

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

@@ -1,28 +0,0 @@
-import { ParseError } from '../../error.js';
-export const object = async (args) => {
-    if (typeof args.value !== 'object' || args.value === null) {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    const isArray = Array.isArray(args.value);
-    if (isArray) {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    args.collect();
-    return args;
-};
-export const record = async (args) => {
-    if (typeof args.value !== 'object' || args.value === null) {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    const isArray = Array.isArray(args.value);
-    if (isArray) {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    args.collect();
-    return args;
-};
-//# sourceMappingURL=object.js.map

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

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

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

@@ -1,136 +0,0 @@
-import { ParseError } from '../../error.js';
-import { isValidId } from '../isValidId.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({
-        value: args.value[key],
-        key,
-        skipCollection: true,
-    });
-    await reference(n);
-    return [n.value];
-}
-const typeIsAllowed = (args, type) => {
-    if ('allowedType' in args.fieldSchema) {
-        const t = args.fieldSchema.allowedType;
-        return typeof t === 'string' && t === type;
-    }
-    return true;
-};
-export 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(ParseError.referenceIsIncorrectType);
-                return;
-            }
-            if (!args.target.errors.length) {
-                args.value = await args.root._opts.asyncOperationHandler(args, 'modifyObject');
-            }
-        }
-        else {
-            args.error(ParseError.nestedModifyObjectNotAllowed);
-            return;
-        }
-    }
-    if (!isValidId(args.schema, args.value)) {
-        args.error(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(ParseError.referenceIsIncorrectType);
-    }
-};
-function parseSortableOp(args, value, op) {
-    if (typeof value[op] !== 'object') {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-    if (!args.fieldSchema.sortable) {
-        args.error(ParseError.incorrectFieldType);
-        return;
-    }
-    switch (typeof value[op].$idx) {
-        case 'bigint':
-            break;
-        case 'number':
-            value[op].$idx = BigInt(value[op].$idx);
-            break;
-        default:
-            args.error(ParseError.incorrectFormat);
-            return;
-    }
-    if (Array.isArray(value[op].$value)) {
-        // NOP
-    }
-    else if (typeof value[op].$value === 'string') {
-        value[op].$value = [value[op].$value];
-    }
-    else {
-        args.error(ParseError.incorrectFormat);
-        return;
-    }
-}
-export const references = async (args) => {
-    const { value } = args;
-    if (typeof value !== 'object' || value === null) {
-        args.error(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 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 if (key === '$assign') {
-                parseSortableOp(args, value, '$assign');
-            }
-            else if (key === '$insert') {
-                parseSortableOp(args, value, '$insert');
-            }
-            else if (key === '$move') {
-                parseSortableOp(args, value, '$move');
-                value.$move.$value.reverse();
-            }
-            else {
-                args.create({ key }).error(ParseError.fieldDoesNotExist);
-            }
-        }
-    }
-    args.collect();
-};
-//# sourceMappingURL=references.js.map

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>;