@based/schema 2.6.0 → 2.7.1

package/dist/src/types.js

@@ -21,4 +21,78 @@ export const isCollection = (type) => {
     return type === 'array' || type === 'object' || type === 'record';
 };
 export const languages = Object.keys(allLanguages);
+export const basedSchemaStringFormatValues = [
+    'email',
+    'URL',
+    'MACAddress',
+    'IP',
+    'IPRange',
+    'FQDN',
+    'IBAN',
+    'BIC',
+    'alpha',
+    'alphaLocales',
+    'alphanumeric',
+    'alphanumericLocales',
+    'passportNumber',
+    'port',
+    'lowercase',
+    'uppercase',
+    'ascii',
+    'semVer',
+    'surrogatePair',
+    'IMEI',
+    'hexadecimal',
+    'octal',
+    'hexColor',
+    'rgbColor',
+    'HSL',
+    'ISRC',
+    'MD5',
+    'JWT',
+    'UUID',
+    'luhnNumber',
+    'creditCard',
+    'identityCard',
+    'EAN',
+    'ISIN',
+    'ISBN',
+    'ISSN',
+    'mobilePhone',
+    'mobilePhoneLocales',
+    'postalCode',
+    'postalCodeLocales',
+    'ethereumAddress',
+    'currency',
+    'btcAddress',
+    'ISO6391',
+    'ISO8601',
+    'RFC3339',
+    'ISO31661Alpha2',
+    'ISO31661Alpha3',
+    'ISO4217',
+    'base32',
+    'base58',
+    'base64',
+    'dataURI',
+    'magnetURI',
+    'mimeType',
+    'latLong',
+    'slug',
+    'strongPassword',
+    'taxID',
+    'licensePlate',
+    'VAT',
+    'code',
+    'typescript',
+    'javascript',
+    'python',
+    'rust',
+    'css',
+    'html',
+    'json',
+    'markdown',
+    'clike',
+    'basedId',
+];
 //# sourceMappingURL=types.js.map

package/dist/src/validateSchema/basedSchemaTypeValidator.d.ts

@@ -0,0 +1,3 @@
+import { BasedSchemaType } from '../types.js';
+import { Validator } from './index.js';
+export declare const basedSchemaTypeValidator: Validator<BasedSchemaType>;

package/dist/src/validateSchema/basedSchemaTypeValidator.js

@@ -0,0 +1,45 @@
+import { deepEqual } from '@saulx/utils';
+import { ParseError } from '../error.js';
+import { mustBeBoolean, mustBeString, mustBeStringArray } from './utils.js';
+import { mustBeFields } from './fieldValidators.js';
+export const basedSchemaTypeValidator = {
+    directory: {
+        validator: mustBeString,
+        optional: true,
+    },
+    fields: {
+        validator: mustBeFields,
+    },
+    title: {
+        validator: mustBeString,
+        optional: true,
+    },
+    description: {
+        validator: mustBeString,
+        optional: true,
+    },
+    prefix: {
+        validator: (value, path) => {
+            if (deepEqual(path, ['root', 'prefix'])) {
+                return value === 'ro'
+                    ? []
+                    : [{ code: ParseError.incorrectFormat, path }];
+            }
+            return /^[a-z]{2}$/.test(value)
+                ? []
+                : [{ code: ParseError.incorrectFormat, path }];
+        },
+        optional: true,
+    },
+    examples: { optional: true },
+    required: {
+        validator: mustBeStringArray,
+        optional: true,
+    },
+    $defs: { optional: true },
+    $delete: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+};
+//# sourceMappingURL=basedSchemaTypeValidator.js.map

package/dist/src/validateSchema/fieldValidators.d.ts

@@ -0,0 +1,27 @@
+import { BasedSchema, BasedSchemaFieldAny, BasedSchemaFieldArray, BasedSchemaFieldBoolean, BasedSchemaFieldCardinality, BasedSchemaFieldEnum, BasedSchemaFieldInteger, BasedSchemaFieldJSON, BasedSchemaFieldNumber, BasedSchemaFieldObject, BasedSchemaFieldRecord, BasedSchemaFieldReference, BasedSchemaFieldReferences, BasedSchemaFieldSet, BasedSchemaFieldShared, BasedSchemaFieldString, BasedSchemaFieldText, BasedSchemaFieldTimeStamp, BasedSchemaNumberDefaults, BasedSchemaPartial, BasedSchemaStringShared } from '../types.js';
+import { ValidateSchemaError, Validator } from './index.js';
+type MustBeFieldOptions = {
+    limitTo?: 'primitives' | 'enumerables';
+};
+export declare const mustBeField: (value: any, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema, options?: MustBeFieldOptions) => ValidateSchemaError[];
+export declare const mustBeFields: (value: any, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema) => ValidateSchemaError[];
+export declare const basedSchemaFieldSharedValidator: Validator<BasedSchemaFieldShared>;
+export declare const basedSchemaStringSharedValidator: Validator<BasedSchemaStringShared>;
+export declare const basedSchemaStringValidator: Validator<BasedSchemaFieldString>;
+export declare const basedSchemaFieldEnumValidator: Validator<BasedSchemaFieldEnum>;
+export declare const basedSchemaFieldCardinalityValidator: Validator<BasedSchemaFieldCardinality>;
+export declare const basedSchemaNumberDefaultsValidator: Validator<BasedSchemaNumberDefaults>;
+export declare const basedSchemaFieldNumberValidator: Validator<BasedSchemaFieldNumber>;
+export declare const basedSchemaFieldIntegerValidator: Validator<BasedSchemaFieldInteger>;
+export declare const basedSchemaFieldTimeStampValidator: Validator<BasedSchemaFieldTimeStamp>;
+export declare const basedSchemaFieldBooleanValidator: Validator<BasedSchemaFieldBoolean>;
+export declare const basedSchemaFieldJSONValidator: Validator<BasedSchemaFieldJSON>;
+export declare const basedSchemaFieldAnyValidator: Validator<BasedSchemaFieldAny>;
+export declare const basedSchemaFieldTextValidator: Validator<BasedSchemaFieldText>;
+export declare const basedSchemaFieldObjectValidator: Validator<BasedSchemaFieldObject>;
+export declare const basedSchemaFieldRecordValidator: Validator<BasedSchemaFieldRecord>;
+export declare const basedSchemaFieldArrayValidator: Validator<BasedSchemaFieldArray>;
+export declare const basedSchemaFieldSetValidator: Validator<BasedSchemaFieldSet>;
+export declare const basedSchemaFieldReferenceValidator: Validator<BasedSchemaFieldReference>;
+export declare const basedSchemaFieldReferencesValidator: Validator<BasedSchemaFieldReferences>;
+export {};

package/dist/src/validateSchema/fieldValidators.js

@@ -0,0 +1,360 @@
+import { basedSchemaNumberFormats } from '../display/number.js';
+import { basedSchemaDisplayFormats } from '../display/string.js';
+import { basedSchemaDateFormats } from '../display/timestamp.js';
+import { ParseError } from '../error.js';
+import { basedSchemaFieldTypes, basedSchemaStringFormatValues, languages, } from '../types.js';
+import { validate } from './index.js';
+import { mustBeArray, mustBeBidirectional, mustBeBoolean, mustBeNumber, mustBeString, mustBeStringArray, } from './utils.js';
+export const mustBeField = (value, path, newSchema, oldSchema, options) => {
+    if (!(typeof value === 'object' && !Array.isArray(value))) {
+        return [
+            {
+                code: ParseError.incorrectFormat,
+                path,
+            },
+        ];
+    }
+    const type = value.hasOwnProperty('enum') ? 'enum' : value.type;
+    if ((options?.limitTo === 'primitives' &&
+        ![
+            'string',
+            'number',
+            'integer',
+            'timestamp',
+            'json',
+            'boolean',
+            'enum',
+        ].includes(type)) ||
+        (options?.limitTo === 'enumerables' &&
+            !['text', 'object', 'record', 'array', 'set'].includes(type))) {
+        return [
+            {
+                code: ParseError.incorrectFormat,
+                path: path.concat('type'),
+            },
+        ];
+    }
+    let validator;
+    switch (type) {
+        case 'string':
+            validator = basedSchemaStringValidator;
+            break;
+        case 'enum':
+            validator = basedSchemaFieldEnumValidator;
+            break;
+        case 'cardinality':
+            validator = basedSchemaFieldCardinalityValidator;
+            break;
+        case 'number':
+            validator = basedSchemaFieldNumberValidator;
+            break;
+        case 'integer':
+            validator = basedSchemaFieldIntegerValidator;
+            break;
+        case 'timestamp':
+            validator = basedSchemaFieldTimeStampValidator;
+            break;
+        case 'boolean':
+            validator = basedSchemaFieldBooleanValidator;
+            break;
+        case 'json':
+            validator = basedSchemaFieldJSONValidator;
+            break;
+        case 'text':
+            validator = basedSchemaFieldTextValidator;
+            break;
+        case 'object':
+            validator = basedSchemaFieldObjectValidator;
+            break;
+        case 'record':
+            validator = basedSchemaFieldRecordValidator;
+            break;
+        case 'array':
+            validator = basedSchemaFieldArrayValidator;
+            break;
+        case 'set':
+            validator = basedSchemaFieldSetValidator;
+            break;
+        case 'reference':
+            validator = basedSchemaFieldReferenceValidator;
+            break;
+        case 'references':
+            validator = basedSchemaFieldReferencesValidator;
+            break;
+        default:
+            validator = basedSchemaFieldSharedValidator;
+            break;
+    }
+    return validate(validator, value, path, newSchema, oldSchema);
+};
+export const mustBeFields = (value, path, newSchema, oldSchema) => {
+    if (!(typeof value === 'object' && !Array.isArray(value))) {
+        return [
+            {
+                code: ParseError.incorrectFormat,
+                path,
+            },
+        ];
+    }
+    const errors = [];
+    for (const key in value) {
+        if (value.hasOwnProperty(key)) {
+            errors.push(...mustBeField(value[key], path.concat(key), newSchema, oldSchema));
+        }
+    }
+    return errors;
+};
+export const basedSchemaFieldSharedValidator = {
+    type: {
+        validator: (value, path) => basedSchemaFieldTypes.includes(value)
+            ? []
+            : [{ code: ParseError.incorrectFieldType, path }],
+    },
+    hooks: {
+        validator: (value, path) => {
+            if (typeof value !== 'object') {
+                return [{ code: ParseError.incorrectFormat, path }];
+            }
+            const items = Array.isArray(value) ? value : [{ ...value }];
+            const errors = [];
+            items.forEach((item, index) => {
+                if (item.hook) {
+                    errors.push(...mustBeString(item.hook, path.concat(Array.isArray(value) ? String(index) : [], 'hook')));
+                }
+                if (item.interval) {
+                    errors.push(...mustBeNumber(item.interval, path.concat(Array.isArray(value) ? String(index) : [], 'interval')));
+                }
+            });
+            return errors;
+        },
+        optional: true,
+    },
+    $id: {
+        validator: mustBeString,
+        optional: true,
+    },
+    isRequired: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+    $schema: {
+        validator: mustBeString,
+        optional: true,
+    },
+    title: {
+        validator: mustBeString,
+        optional: true,
+    },
+    description: {
+        validator: mustBeString,
+        optional: true,
+    },
+    index: {
+        validator: mustBeNumber,
+        optional: true,
+    },
+    readOnly: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+    writeOnly: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+    $comment: {
+        validator: mustBeString,
+        optional: true,
+    },
+    examples: { optional: true },
+    default: { optional: true },
+    customValidator: { optional: true },
+    $defs: { optional: true },
+    $delete: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+};
+export const basedSchemaStringSharedValidator = {
+    minLength: {
+        validator: mustBeNumber,
+        optional: true,
+    },
+    maxLength: {
+        validator: mustBeNumber,
+        optional: true,
+    },
+    contentMediaEncoding: {
+        validator: mustBeString,
+        optional: true,
+    },
+    contentMediaType: {
+        validator: (value, path) => /^\w+\/\w+$/.test(value)
+            ? []
+            : [{ code: ParseError.incorrectFormat, path }],
+        optional: true,
+    },
+    pattern: {
+        validator: mustBeString,
+        optional: true,
+    },
+    format: {
+        validator: (value, path) => basedSchemaStringFormatValues.includes(value)
+            ? []
+            : [{ code: ParseError.incorrectFormat, path }],
+        optional: true,
+    },
+    display: {
+        validator: (value, path) => basedSchemaDisplayFormats.includes(value)
+            ? []
+            : [{ code: ParseError.incorrectFormat, path }],
+        optional: true,
+    },
+    multiline: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+};
+export const basedSchemaStringValidator = {
+    ...basedSchemaFieldSharedValidator,
+    ...basedSchemaStringSharedValidator,
+};
+export const basedSchemaFieldEnumValidator = {
+    ...basedSchemaFieldSharedValidator,
+    enum: {
+        validator: mustBeArray,
+    },
+};
+export const basedSchemaFieldCardinalityValidator = {
+    ...basedSchemaFieldSharedValidator,
+};
+export const basedSchemaNumberDefaultsValidator = {
+    multipleOf: {
+        validator: mustBeNumber,
+        optional: true,
+    },
+    minimum: {
+        validator: mustBeNumber,
+        optional: true,
+    },
+    maximum: {
+        validator: mustBeNumber,
+        optional: true,
+    },
+    exclusiveMaximum: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+    exclusiveMinimum: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+};
+export const basedSchemaFieldNumberValidator = {
+    ...basedSchemaFieldSharedValidator,
+    ...basedSchemaNumberDefaultsValidator,
+    display: {
+        validator: (value, path) => basedSchemaNumberFormats.includes(value) || /^round-\d+$/.test(value)
+            ? []
+            : [{ code: ParseError.incorrectFormat, path }],
+        optional: true,
+    },
+};
+export const basedSchemaFieldIntegerValidator = {
+    ...basedSchemaFieldSharedValidator,
+    ...basedSchemaNumberDefaultsValidator,
+    display: {
+        validator: (value, path) => basedSchemaNumberFormats.includes(value) || /^round-\d+$/.test(value)
+            ? []
+            : [{ code: ParseError.incorrectFormat, path }],
+        optional: true,
+    },
+};
+export const basedSchemaFieldTimeStampValidator = {
+    ...basedSchemaFieldSharedValidator,
+    ...basedSchemaNumberDefaultsValidator,
+    display: {
+        validator: (value, path) => basedSchemaDateFormats.includes(value)
+            ? []
+            : [{ code: ParseError.incorrectFormat, path }],
+        optional: true,
+    },
+};
+export const basedSchemaFieldBooleanValidator = {
+    ...basedSchemaFieldSharedValidator,
+};
+export const basedSchemaFieldJSONValidator = {
+    ...basedSchemaFieldSharedValidator,
+    format: {
+        validator: (value, path) => value === 'rich-text' ? [] : [{ code: ParseError.incorrectFormat, path }],
+        optional: true,
+    },
+};
+export const basedSchemaFieldAnyValidator = {
+    ...basedSchemaFieldSharedValidator,
+};
+export const basedSchemaFieldTextValidator = {
+    ...basedSchemaFieldSharedValidator,
+    ...basedSchemaStringSharedValidator,
+    required: {
+        validator: (value, path) => Array.isArray(value) &&
+            value.every((i) => Object.keys(languages).includes(i))
+            ? []
+            : [{ code: ParseError.languageNotSupported, path }],
+        optional: true,
+    },
+};
+export const basedSchemaFieldObjectValidator = {
+    ...basedSchemaFieldSharedValidator,
+    properties: {
+        validator: mustBeFields,
+    },
+    required: {
+        validator: mustBeStringArray,
+        optional: true,
+    },
+};
+export const basedSchemaFieldRecordValidator = {
+    ...basedSchemaFieldSharedValidator,
+    values: {
+        validator: mustBeField,
+    },
+};
+export const basedSchemaFieldArrayValidator = {
+    ...basedSchemaFieldSharedValidator,
+    values: {
+        validator: mustBeField,
+    },
+};
+export const basedSchemaFieldSetValidator = {
+    ...basedSchemaFieldSharedValidator,
+    items: {
+        validator: (value, path, newSchema, oldSchema) => mustBeField(value, path, newSchema, oldSchema, { limitTo: 'primitives' }),
+    },
+};
+export const basedSchemaFieldReferenceValidator = {
+    ...basedSchemaFieldSharedValidator,
+    bidirectional: {
+        validator: mustBeBidirectional,
+        optional: true,
+    },
+    allowedTypes: {
+        // TODO: validator
+        optional: true,
+    },
+};
+export const basedSchemaFieldReferencesValidator = {
+    ...basedSchemaFieldSharedValidator,
+    bidirectional: {
+        validator: mustBeBidirectional,
+        optional: true,
+    },
+    allowedTypes: {
+        // TODO: validator
+        optional: true,
+    },
+    sortable: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+};
+//# sourceMappingURL=fieldValidators.js.map

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

@@ -0,0 +1,17 @@
+import { ParseError } from '../error.js';
+import { BasedSchema, BasedSchemaPartial } from '../types.js';
+export type ValidateSchemaError = {
+    code: ParseError;
+    path?: string[];
+};
+export type Validator<T> = {
+    [P in keyof Required<T>]: {
+        optional?: boolean;
+        validator?: (value: any, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema) => ValidateSchemaError[];
+    };
+};
+export declare const validate: <T>(validator: Validator<T>, target: T, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema) => ValidateSchemaError[];
+export declare const validateSchema: (newSchema: BasedSchemaPartial, oldSchema?: BasedSchema) => Promise<{
+    valid?: true;
+    errors?: ValidateSchemaError[];
+}>;

package/dist/src/validateSchema/index.js

@@ -0,0 +1,109 @@
+import { ParseError } from '../error.js';
+import { languages, } from '../types.js';
+import { basedSchemaTypeValidator } from './basedSchemaTypeValidator.js';
+const basedSchemaValidator = {
+    language: {
+        validator: (value, path) => 
+        // language not supported
+        languages.includes(value)
+            ? []
+            : [{ code: ParseError.languageNotSupported, path }],
+    },
+    translations: {
+        validator: (value, path, newSchema, oldSchema) => {
+            // translations property needs to be an array
+            if (!Array.isArray(value)) {
+                return [{ code: ParseError.incorrectFormat, path }];
+            }
+            const language = newSchema.language || oldSchema.language;
+            // translations property cannot include language value
+            if (language && value.includes(language)) {
+                return [{ code: ParseError.invalidProperty, path }];
+            }
+            // language not supported
+            return value.every((l) => languages.includes(l))
+                ? []
+                : [{ code: ParseError.languageNotSupported, path }];
+        },
+        optional: true,
+    },
+    languageFallbacks: {
+        validator: (value, path, newSchema, oldSchema) => {
+            // languageFallbacks needs to be an object
+            if (typeof value !== 'object' || Array.isArray(value)) {
+                return [{ code: ParseError.incorrectFormat, path }];
+            }
+            const schemaLangs = [newSchema.language || oldSchema?.language].concat(newSchema.translations || oldSchema?.translations);
+            for (const key in value) {
+                // languageFallbacks keys must be a language or a translation
+                if (!schemaLangs.includes(key)) {
+                    return [{ code: ParseError.noLanguageFound, path }];
+                }
+                // languageFallbacks language values need to be array
+                if (!Array.isArray(value[key])) {
+                    return [{ code: ParseError.incorrectFormat, path }];
+                }
+                if (!value[key].every((l) => schemaLangs.includes(l))) {
+                    return [{ code: ParseError.noLanguageFound, path }];
+                }
+            }
+            return [];
+        },
+        optional: true,
+    },
+    root: {
+        validator: (value, path, newSchema, oldSchema) => validate(basedSchemaTypeValidator, value, path, newSchema, oldSchema),
+    },
+    $defs: {},
+    types: {
+        validator: (value, path, newSchema, oldSchema) => {
+            if (!(typeof value === 'object' && !Array.isArray(value))) {
+                return [
+                    {
+                        code: ParseError.incorrectFormat,
+                        path,
+                    },
+                ];
+            }
+            const errors = [];
+            for (const key in value) {
+                if (value.hasOwnProperty(key)) {
+                    errors.push(...validate(basedSchemaTypeValidator, value[key], path.concat(key), newSchema, oldSchema));
+                }
+            }
+            return errors;
+        },
+    },
+    // TODO:
+    prefixToTypeMapping: {},
+};
+export const validate = (validator, target, path, newSchema, oldSchema) => {
+    const errors = [];
+    for (const key in target) {
+        if (target.hasOwnProperty(key)) {
+            if (validator[key]) {
+                if (validator[key].validator) {
+                    const result = validator[key].validator(target[key], path.concat(key), newSchema, oldSchema);
+                    errors.push(...result);
+                }
+            }
+            else {
+                errors.push({
+                    code: ParseError.invalidProperty,
+                    path: path.concat(key),
+                });
+            }
+        }
+    }
+    return errors;
+};
+export const validateSchema = async (newSchema, oldSchema) => {
+    const errors = [];
+    if (newSchema === null || typeof newSchema !== 'object') {
+        errors.push({ code: ParseError.invalidSchemaFormat });
+        return { errors };
+    }
+    errors.push(...validate(basedSchemaValidator, newSchema, [], newSchema, oldSchema));
+    return errors.length ? { errors } : { valid: true };
+};
+//# sourceMappingURL=index.js.map

package/dist/src/validateSchema/utils.d.ts

@@ -0,0 +1,25 @@
+import { ParseError } from '../error.js';
+export declare const mustBeString: (value: string, path: string[]) => {
+    code: ParseError;
+    path: string[];
+}[];
+export declare const mustBeArray: (value: string[], path: string[]) => {
+    code: ParseError;
+    path: string[];
+}[];
+export declare const mustBeStringArray: (value: string[], path: string[]) => {
+    code: ParseError;
+    path: string[];
+}[];
+export declare const mustBeBoolean: (value: string, path: string[]) => {
+    code: ParseError;
+    path: string[];
+}[];
+export declare const mustBeNumber: (value: string, path: string[]) => {
+    code: ParseError;
+    path: string[];
+}[];
+export declare const mustBeBidirectional: (value: any, path: string[]) => {
+    code: ParseError;
+    path: string[];
+}[];