@based/schema 3.1.0 → 3.2.0

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

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

package/dist/set/fields/set.js

@@ -0,0 +1,63 @@
+"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

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

package/dist/set/fields/string.js

@@ -0,0 +1,284 @@
+"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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,183 @@
+"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

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

package/dist/set/isValidId.js

@@ -0,0 +1,21 @@
+"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

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

package/dist/src/compat/index.js

@@ -58,7 +58,7 @@ const convertOldToNewMeta = (props) => {
 };
 const convertNewFieldToOldField = (newField) => {
     // @ts-ignore
-    const { type, properties, values, items, ...props } = newField;
+    const { type, bidirectional, properties, values, items, ...props } = newField;
     const meta = convertNewToOldMeta(props);
     // @ts-ignore
     const overwrite = newToOldType[type] || newToOldType[props.format];
@@ -70,6 +70,10 @@ const convertNewFieldToOldField = (newField) => {
     if (meta) {
         oldField.meta = meta;
     }
+    if (bidirectional) {
+        // @ts-ignore
+        oldField.bidirectional = bidirectional;
+    }
     if (properties) {
         // @ts-ignore
         oldField.properties = {};
@@ -133,7 +137,7 @@ export const convertNewToOld = (newSchema) => {
 };
 const convertOldFieldToNewField = (oldField) => {
     // @ts-ignore
-    const { type, properties, values, items, meta = {} } = oldField;
+    const { type, bidirectional, properties, values, items, meta = {} } = oldField;
     const overwrite = oldToNewType[type] || oldToNewType[meta.format];
     const newField = overwrite
         ? {
@@ -144,6 +148,10 @@ const convertOldFieldToNewField = (oldField) => {
             type,
             ...convertOldToNewMeta(meta),
         };
+    if (bidirectional) {
+        // @ts-ignore
+        newField.bidirectional = bidirectional;
+    }
     if (properties) {
         // @ts-ignore
         newField.properties = {};

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

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