@based/schema 2.6.0 → 2.7.0

package/dist/src/display/string.js

@@ -1,3 +1,8 @@
+export const basedSchemaDisplayFormats = [
+    'lowercase',
+    'uppercase',
+    'capitalize',
+];
 const parseString = (value, format) => {
     if (!format) {
         return value;

package/dist/src/display/timestamp.d.ts

@@ -1,3 +1,5 @@
-export type DateFormat = 'date' | 'date-time' | 'date-time-text' | 'human' | 'time' | 'time-precise';
+export declare const basedSchemaDateFormats: readonly [any, "date", "date-time", "date-time-text", "human", "time", "time-precise"];
+export type BasedSchemaDateFormat = (typeof basedSchemaDateFormats)[number];
+export type DateFormat = BasedSchemaDateFormat;
 declare const _default: (nr: number | string, format?: DateFormat) => string | number;
 export default _default;

package/dist/src/display/timestamp.js

@@ -1,3 +1,12 @@
+export const basedSchemaDateFormats = [
+    ,
+    'date',
+    'date-time',
+    'date-time-text',
+    'human',
+    'time',
+    'time-precise',
+];
 const addZero = (d) => {
     const s = d + '';
     if (s.length === 1) {

package/dist/src/error.d.ts

@@ -15,5 +15,7 @@ export declare enum ParseError {
     'noLanguageFound' = 13,
     'cannotDeleteNodeFromModify' = 14,
     'nestedModifyObjectNotAllowed' = 15,
-    'infinityNotSupported' = 16
+    'infinityNotSupported' = 16,
+    'invalidSchemaFormat' = 17,
+    'invalidProperty' = 18
 }

package/dist/src/error.js

@@ -17,5 +17,7 @@ export var ParseError;
     ParseError[ParseError["cannotDeleteNodeFromModify"] = 14] = "cannotDeleteNodeFromModify";
     ParseError[ParseError["nestedModifyObjectNotAllowed"] = 15] = "nestedModifyObjectNotAllowed";
     ParseError[ParseError["infinityNotSupported"] = 16] = "infinityNotSupported";
+    ParseError[ParseError["invalidSchemaFormat"] = 17] = "invalidSchemaFormat";
+    ParseError[ParseError["invalidProperty"] = 18] = "invalidProperty";
 })(ParseError || (ParseError = {}));
 //# sourceMappingURL=error.js.map

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 export * from './types.js';
-export * from './validateSchema.js';
+export * from './validateSchema/index.js';
 export * from './walker/index.js';
 export * from './set/index.js';
 export * from './display/index.js';

package/dist/src/index.js

@@ -1,5 +1,5 @@
 export * from './types.js';
-export * from './validateSchema.js';
+export * from './validateSchema/index.js';
 export * from './walker/index.js';
 export * from './set/index.js';
 export * from './display/index.js';

package/dist/src/types.d.ts

@@ -43,23 +43,25 @@ export type BasedSchemaFieldShared = {
     };
     $delete?: boolean;
 };
+export declare const basedSchemaStringFormatValues: readonly ["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"];
 export type BasedSchemaStringShared = {
     minLength?: number;
     maxLength?: number;
     contentMediaEncoding?: string;
     contentMediaType?: BasedSchemaContentMediaType;
     pattern?: BasedSchemaPattern;
-    format?: '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';
+    format?: (typeof basedSchemaStringFormatValues)[number];
     display?: StringFormat;
     multiline?: boolean;
 };
-type NumberDefaults = {
+export type BasedSchemaNumberDefaults = {
     multipleOf?: number;
     minimum?: number;
     maximum?: number;
     exclusiveMaximum?: boolean;
     exclusiveMinimum?: boolean;
 };
+export type NumberDefaults = BasedSchemaNumberDefaults;
 export type BasedNumberDisplay = NumberFormat;
 export type BasedTimestampDisplay = DateFormat;
 export type BasedSchemaFieldString = {
@@ -209,4 +211,3 @@ export type BasedSchemaCollectProps = ArgsClass<BasedSetTarget> & {
         typeSchema: BasedSchemaType;
     };
 };
-export {};

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,352 @@
+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 { 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.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;
+        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: {},
+};
+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[];
+}>;