@based/schema 4.1.1 → 5.0.0-alpha.1

package/dist/src/languages.js

@@ -1,188 +0,0 @@
-export const 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',
-    gsw: 'Swiss 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/src/set/fields/array.d.ts

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

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

@@ -1,119 +0,0 @@
-import { setByPath } from '@saulx/utils';
-import { ParseError } from '../../error.js';
-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.items.type);
-    const collected = [];
-    for (let i = 0; i < fromValue.length; i++) {
-        q.push(args.parse({
-            key: i + idx,
-            value: fromValue[i],
-            fieldSchema: args.fieldSchema.items,
-            collect: (nArgs) => {
-                const p = nArgs.path.slice(args.path.length);
-                // @ts-ignore
-                p[0] = p[0] - idx;
-                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(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(ParseError.incorrectFormat);
-            return;
-        }
-        args.collect(value);
-    },
-    $assign: async (args, value) => {
-        if (typeof value.$assign !== 'object' ||
-            typeof value.$assign.$idx !== 'number') {
-            args.error(ParseError.incorrectFormat);
-            return;
-        }
-        await args.parse({
-            key: value.$assign.$idx,
-            value: value.$assign.$value,
-            fieldSchema: args.fieldSchema.items,
-        });
-    },
-};
-export const array = async (args) => {
-    args.stop();
-    if (typeof args.value !== 'object') {
-        args.error(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.items,
-            }));
-        }
-        await Promise.all(q);
-        return;
-    }
-    let hasOperation = false;
-    for (const key in value) {
-        if (operations[key]) {
-            if (hasOperation) {
-                args.error(ParseError.multipleOperationsNotAllowed);
-                return;
-            }
-            await operations[key](args, value);
-            hasOperation = true;
-        }
-        else {
-            args.error(ParseError.fieldDoesNotExist);
-        }
-    }
-};
-//# sourceMappingURL=array.js.map

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

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

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

@@ -1,85 +0,0 @@
-import { ParseError } from '../../error.js';
-import { array } from './array.js';
-import { object, record } from './object.js';
-import { number, integer, timestamp } from './number.js';
-import { string, text } from './string.js';
-import { reference, references } from './references.js';
-import { set } from './set.js';
-import { hashObjectIgnoreKeyOrder, hash } from '@saulx/hash';
-import { deepEqual } from '@saulx/utils';
-export const fields = {
-    array,
-    object,
-    record,
-    number,
-    integer,
-    timestamp,
-    string,
-    set,
-    text,
-    reference,
-    references,
-    cardinality: async (args) => {
-        let hashedValue;
-        if (args.value && typeof args.value === 'object') {
-            args.stop();
-            if (args.value.$default !== undefined) {
-                args.error(ParseError.defaultNotSupported);
-                return;
-            }
-            if (args.value.$value !== undefined) {
-                hashedValue = hashObjectIgnoreKeyOrder(args.value.$value).toString(16);
-            }
-            else {
-                hashedValue = hashObjectIgnoreKeyOrder(args.value).toString(16);
-            }
-        }
-        else {
-            hashedValue = hash(args.value).toString(16);
-        }
-        args.collect(hashedValue);
-    },
-    boolean: async (args) => {
-        if (typeof args.value !== 'boolean') {
-            args.error(ParseError.incorrectFormat);
-            return;
-        }
-        args.collect();
-    },
-    json: async (args) => {
-        args.stop();
-        try {
-            const parsedValue = JSON.stringify(args.value);
-            args.collect(parsedValue);
-        }
-        catch (err) {
-            args.error(ParseError.invalidJSON);
-        }
-    },
-    enum: async (args) => {
-        const enumValues = args.fieldSchema.enum;
-        for (let i = 0; i < enumValues.length; i++) {
-            if (deepEqual(enumValues[i], args.value)) {
-                args.collect(i);
-                return;
-            }
-        }
-        args.error(ParseError.incorrectFormat);
-    },
-    any: async (args) => {
-        args.stop();
-        if (typeof args.value !== 'object') {
-            args.collect(args.value);
-            return;
-        }
-        const q = [];
-        for (const key in args.value) {
-            q.push(args.parse({
-                key: key,
-                value: args.value[key],
-                fieldSchema: { type: 'any' },
-            }));
-        }
-    },
-};
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,123 +0,0 @@
-import { ParseError } from '../../error.js';
-const validateNumber = (args, value, ignoreMinMax) => {
-    const { fieldSchema } = args;
-    if (typeof value !== 'number') {
-        args.error(ParseError.incorrectFormat);
-        return false;
-    }
-    if (isNaN(value)) {
-        args.error(ParseError.incorrectFormat);
-        return false;
-    }
-    if (value === Infinity || value === -Infinity) {
-        args.error(ParseError.infinityNotSupported);
-        return false;
-    }
-    if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
-        args.error(ParseError.incorrectFormat);
-        return false;
-    }
-    if (fieldSchema.multipleOf &&
-        value / fieldSchema.multipleOf -
-            Math.floor(value / fieldSchema.multipleOf) !==
-            0) {
-        args.error(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(ParseError.exceedsMaximum);
-                return false;
-            }
-        }
-        else if (value > fieldSchema.maximum) {
-            args.error(ParseError.exceedsMaximum);
-            return false;
-        }
-    }
-    if (fieldSchema.minimum) {
-        if (fieldSchema.exclusiveMinimum) {
-            if (value <= fieldSchema.minimum) {
-                args.error(ParseError.subceedsMinimum);
-                return false;
-            }
-        }
-        else if (value < fieldSchema.minimum) {
-            args.error(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(ParseError.fieldDoesNotExist);
-            return false;
-        }
-    }
-    return true;
-};
-export const number = async (args) => {
-    if (!validate(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-export const integer = async (args) => {
-    if (!validate(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-export 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(ParseError.incorrectFormat);
-                return;
-            }
-        }
-    }
-    if (!validateNumber(args, args.value)) {
-        return;
-    }
-    args.collect();
-};
-//# sourceMappingURL=number.js.map

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