@based/schema 2.7.1 → 3.0.0

package/dist/languages.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.languages = void 0;
+exports.languages = {
+    ab: 'Abkhazian',
+    aa: 'Afar',
+    af: 'Afrikaans',
+    ak: 'Akan',
+    sq: 'Albanian',
+    am: 'Amharic',
+    ar: 'Arabic',
+    an: 'Aragonese',
+    hy: 'Armenian',
+    as: 'Assamese',
+    av: 'Avaric',
+    ae: 'Avestan',
+    ay: 'Aymara',
+    az: 'Azerbaijani',
+    bm: 'Bambara',
+    ba: 'Bashkir',
+    eu: 'Basque',
+    be: 'Belarusian',
+    bn: 'Bengali',
+    bh: 'Bihari languages',
+    bi: 'Bislama',
+    bs: 'Bosnian',
+    br: 'Breton',
+    bg: 'Bulgarian',
+    my: 'Burmese',
+    ca: 'Catalan, Valencian',
+    km: 'Central Khmer',
+    ch: 'Chamorro',
+    ce: 'Chechen',
+    ny: 'Chichewa, Chewa, Nyanja',
+    zh: 'Chinese',
+    cu: 'Church Slavonic, Old Bulgarian, Old Church Slavonic',
+    cv: 'Chuvash',
+    kw: 'Cornish',
+    co: 'Corsican',
+    cr: 'Cree',
+    hr: 'Croatian',
+    cs: 'Czech',
+    da: 'Danish',
+    dv: 'Divehi, Dhivehi, Maldivian',
+    nl: 'Dutch, Flemish',
+    dz: 'Dzongkha',
+    en: 'English',
+    eo: 'Esperanto',
+    et: 'Estonian',
+    ee: 'Ewe',
+    fo: 'Faroese',
+    fj: 'Fijian',
+    fi: 'Finnish',
+    fr: 'French',
+    ff: 'Fulah',
+    gd: 'Gaelic, Scottish Gaelic',
+    gl: 'Galician',
+    lg: 'Ganda',
+    ka: 'Georgian',
+    de: 'German',
+    ki: 'Gikuyu, Kikuyu',
+    el: 'Greek (Modern)',
+    kl: 'Greenlandic, Kalaallisut',
+    gn: 'Guarani',
+    gu: 'Gujarati',
+    ht: 'Haitian, Haitian Creole',
+    ha: 'Hausa',
+    he: 'Hebrew',
+    hz: 'Herero',
+    hi: 'Hindi',
+    ho: 'Hiri Motu',
+    hu: 'Hungarian',
+    is: 'Icelandic',
+    io: 'Ido',
+    ig: 'Igbo',
+    id: 'Indonesian',
+    ia: 'Interlingua (International Auxiliary Language Association)',
+    ie: 'Interlingue',
+    iu: 'Inuktitut',
+    ik: 'Inupiaq',
+    ga: 'Irish',
+    it: 'Italian',
+    ja: 'Japanese',
+    jv: 'Javanese',
+    kn: 'Kannada',
+    kr: 'Kanuri',
+    ks: 'Kashmiri',
+    kk: 'Kazakh',
+    rw: 'Kinyarwanda',
+    kv: 'Komi',
+    kg: 'Kongo',
+    ko: 'Korean',
+    kj: 'Kwanyama, Kuanyama',
+    ku: 'Kurdish',
+    ky: 'Kyrgyz',
+    lo: 'Lao',
+    la: 'Latin',
+    lv: 'Latvian',
+    lb: 'Letzeburgesch, Luxembourgish',
+    li: 'Limburgish, Limburgan, Limburger',
+    ln: 'Lingala',
+    lt: 'Lithuanian',
+    lu: 'Luba-Katanga',
+    mk: 'Macedonian',
+    mg: 'Malagasy',
+    ms: 'Malay',
+    ml: 'Malayalam',
+    mt: 'Maltese',
+    gv: 'Manx',
+    mi: 'Maori',
+    mr: 'Marathi',
+    mh: 'Marshallese',
+    ro: 'Moldovan, Moldavian, Romanian',
+    mn: 'Mongolian',
+    na: 'Nauru',
+    nv: 'Navajo, Navaho',
+    nd: 'Northern Ndebele',
+    ng: 'Ndonga',
+    ne: 'Nepali',
+    se: 'Northern Sami',
+    no: 'Norwegian',
+    nb: 'Norwegian Bokmål',
+    nn: 'Norwegian Nynorsk',
+    ii: 'Nuosu, Sichuan Yi',
+    oc: 'Occitan (post 1500)',
+    oj: 'Ojibwa',
+    or: 'Oriya',
+    om: 'Oromo',
+    os: 'Ossetian, Ossetic',
+    pi: 'Pali',
+    pa: 'Panjabi, Punjabi',
+    ps: 'Pashto, Pushto',
+    fa: 'Persian',
+    pl: 'Polish',
+    pt: 'Portuguese',
+    qu: 'Quechua',
+    rm: 'Romansh',
+    rn: 'Rundi',
+    ru: 'Russian',
+    sm: 'Samoan',
+    sg: 'Sango',
+    sa: 'Sanskrit',
+    sc: 'Sardinian',
+    sr: 'Serbian',
+    sn: 'Shona',
+    sd: 'Sindhi',
+    si: 'Sinhala, Sinhalese',
+    sk: 'Slovak',
+    sl: 'Slovenian',
+    so: 'Somali',
+    st: 'Sotho, Southern',
+    nr: 'South Ndebele',
+    es: 'Spanish, Castilian',
+    su: 'Sundanese',
+    sw: 'Swahili',
+    ss: 'Swati',
+    sv: 'Swedish',
+    tl: 'Tagalog',
+    ty: 'Tahitian',
+    tg: 'Tajik',
+    ta: 'Tamil',
+    tt: 'Tatar',
+    te: 'Telugu',
+    th: 'Thai',
+    bo: 'Tibetan',
+    ti: 'Tigrinya',
+    to: 'Tonga (Tonga Islands)',
+    ts: 'Tsonga',
+    tn: 'Tswana',
+    tr: 'Turkish',
+    tk: 'Turkmen',
+    tw: 'Twi',
+    ug: 'Uighur, Uyghur',
+    uk: 'Ukrainian',
+    ur: 'Urdu',
+    uz: 'Uzbek',
+    ve: 'Venda',
+    vi: 'Vietnamese',
+    vo: 'Volap_k',
+    wa: 'Walloon',
+    cy: 'Welsh',
+    fy: 'Western Frisian',
+    wo: 'Wolof',
+    xh: 'Xhosa',
+    yi: 'Yiddish',
+    yo: 'Yoruba',
+    za: 'Zhuang, Chuang',
+    zu: 'Zulu',
+};
+//# sourceMappingURL=languages.js.map

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

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

package/dist/set/fields/array.js

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

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

package/dist/set/fields/index.js

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

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

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

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

package/dist/set/fields/object.js

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

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

package/dist/set/fields/references.js

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