@based/schema 4.1.0 → 5.0.0-alpha.0

package/dist/src/set/index.js

@@ -1,205 +0,0 @@
-import { ParseError } from '../error.js';
-import { walk } from '../walker/index.js';
-import { fields } from './fields/index.js';
-import { isValidId } from './isValidId.js';
-const opts = {
-    parsers: {
-        keys: {
-            $delete: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (args.prev === args.root) {
-                    args.error(ParseError.cannotDeleteNodeFromModify);
-                    return;
-                }
-                if (args.value === true) {
-                    args.stop();
-                    args.prev.collect();
-                    args.prev.stop();
-                    return;
-                }
-            },
-            $alias: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (Array.isArray(args.value)) {
-                    for (const field of args.value) {
-                        if (typeof field !== 'string') {
-                            args.error(ParseError.incorrectFormat);
-                            return;
-                        }
-                    }
-                    return;
-                }
-                if (typeof args.value !== 'string') {
-                    args.error(ParseError.incorrectFormat);
-                }
-            },
-            $merge: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (typeof args.value !== 'boolean') {
-                    args.error(ParseError.incorrectFormat);
-                    return;
-                }
-                if (args.prev !== args.root) {
-                    args.prev.collect({ $delete: true });
-                }
-                return;
-            },
-            $id: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (!isValidId(args.schema, args.value)) {
-                    args.error(ParseError.incorrectFormat);
-                    return;
-                }
-            },
-            $language: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'json') {
-                    return;
-                }
-                if (!(args.schema.translations || [])
-                    .concat(args.schema.language)
-                    .includes(args.value)) {
-                    args.error(ParseError.languageNotSupported);
-                    return;
-                }
-            },
-            $value: async (args) => {
-                const type = args.fieldSchema?.type;
-                if (type === 'text' ||
-                    type === 'set' ||
-                    type == 'references' ||
-                    type === 'json') {
-                    return;
-                }
-                args.prev.stop();
-                args.stop();
-                if (args.prev.value.$default) {
-                    args.error(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' ||
-                    type === 'json') {
-                    // 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(ParseError.fieldDoesNotExist);
-                    }
-                }
-            },
-        },
-        fields,
-        catch: async (args) => {
-            args.error(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(ParseError.incorrectFieldType, { target });
-                return { target };
-            }
-        }
-        else if (value.$alias) {
-            target.$alias = value.$alias;
-        }
-        if (value.type) {
-            if (type && value.type !== type) {
-                error(ParseError.incorrectNodeType, { target });
-                return { target };
-            }
-            type = value.type;
-        }
-        const typeSchema = type === 'root' ? schema.root : schema.types[type];
-        if (!typeSchema) {
-            error(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(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);
-    },
-};
-export const setWalker = (schema, value, asyncOperationHandler) => {
-    return walk(schema, opts, value, asyncOperationHandler);
-};
-//# sourceMappingURL=index.js.map

package/dist/src/set/isValidId.d.ts

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

package/dist/src/set/isValidId.js

@@ -1,17 +0,0 @@
-export 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;
-};
-//# sourceMappingURL=isValidId.js.map

package/dist/src/types.d.ts

@@ -1,205 +0,0 @@
-import type { Language } from './languages.js';
-import type { PartialDeep } from 'type-fest';
-import { ParseError } from './error.js';
-import { ArgsClass, Path } from './walker/index.js';
-import { StringFormat } from './display/string.js';
-import { NumberFormat } from './display/number.js';
-import { DateFormat } from './display/timestamp.js';
-export declare const basedSchemaFieldTypes: readonly ["array", "object", "record", "set", "string", "boolean", "number", "json", "integer", "timestamp", "created", "updated", "reference", "references", "text", "enum", "cardinality", "any"];
-export type BasedSchemaFieldType = (typeof basedSchemaFieldTypes)[number];
-export declare const isCollection: (type: string) => boolean;
-export type BasedSchemaPattern = string;
-export type BasedSchemaLanguage = Language;
-export declare const languages: string[];
-export type BasedSchemaTypePrefix = string;
-export type BasedSchemaContentMediaType = 'text/html' | 'text/plain' | 'text/markdown' | 'image/png' | 'image/jpeg' | 'video/mp4' | 'image/*' | 'video/*' | 'audio/*' | '*/*' | `${string}/${string}`;
-export type BasedSchemaFieldShared = {
-    hooks?: {
-        interval?: number;
-        hook: string;
-    } | {
-        interval?: number;
-        hook: string;
-    }[];
-    type?: BasedSchemaFieldType;
-    $id?: string;
-    $schema?: string;
-    isRequired?: boolean;
-    title?: string;
-    description?: string;
-    index?: number;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-    $comment?: string;
-    examples?: any[];
-    default?: any;
-    customValidator?: (value: any, path: (number | string)[], target: BasedSetTarget) => Promise<boolean>;
-    $defs?: {
-        [key: string]: BasedSchemaField;
-    };
-    $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", "basedType"];
-export type BasedSchemaStringShared = {
-    minLength?: number;
-    maxLength?: number;
-    contentMediaEncoding?: string;
-    contentMediaType?: BasedSchemaContentMediaType;
-    pattern?: BasedSchemaPattern;
-    format?: (typeof basedSchemaStringFormatValues)[number];
-    display?: StringFormat;
-    multiline?: boolean;
-};
-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 = {
-    type: 'string';
-} & BasedSchemaFieldShared & BasedSchemaStringShared;
-export type BasedSchemaFieldEnum = {
-    enum: any[];
-    type?: '';
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldCardinality = {
-    type: 'cardinality';
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldNumber = NumberDefaults & {
-    type: 'number';
-    display?: BasedNumberDisplay;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldInteger = NumberDefaults & {
-    type: 'integer';
-    display?: BasedNumberDisplay;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldTimeStamp = NumberDefaults & {
-    type: 'timestamp';
-    display?: BasedTimestampDisplay;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldBoolean = {
-    type: 'boolean';
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldJSON = {
-    type: 'json';
-    format?: 'rich-text';
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldAny = {
-    type: 'any';
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldPrimitive = BasedSchemaFieldString | BasedSchemaFieldNumber | BasedSchemaFieldInteger | BasedSchemaFieldTimeStamp | BasedSchemaFieldJSON | BasedSchemaFieldBoolean | BasedSchemaFieldEnum;
-export type BasedSchemaFieldText = {
-    type: 'text';
-    required?: BasedSchemaLanguage[];
-} & BasedSchemaFieldShared & BasedSchemaStringShared;
-export type BasedSchemaFieldObject = {
-    type: 'object';
-    properties: {
-        [name: string]: BasedSchemaField;
-    };
-    required?: string[];
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldRecord = {
-    type: 'record';
-    values: BasedSchemaField;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldArray = {
-    type: 'array';
-    items: BasedSchemaField;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldSet = {
-    type: 'set';
-    items: BasedSchemaFieldPrimitive;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldEnumerable = BasedSchemaFieldText | BasedSchemaFieldObject | BasedSchemaFieldRecord | BasedSchemaFieldArray | BasedSchemaFieldSet;
-export type BasedSchemaFieldReference = {
-    type: 'reference';
-    allowedType: string;
-    inverseProperty?: string;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFieldReferences = {
-    type: 'references';
-    allowedType: string;
-    inverseProperty?: string;
-    sortable?: boolean;
-} & BasedSchemaFieldShared;
-export type BasedSchemaFields = {
-    string: BasedSchemaFieldString;
-    number: BasedSchemaFieldNumber;
-    integer: BasedSchemaFieldInteger;
-    timestamp: BasedSchemaFieldTimeStamp;
-    json: BasedSchemaFieldJSON;
-    boolean: BasedSchemaFieldBoolean;
-    enum: BasedSchemaFieldEnum;
-    array: BasedSchemaFieldArray;
-    object: BasedSchemaFieldObject;
-    set: BasedSchemaFieldSet;
-    record: BasedSchemaFieldRecord;
-    reference: BasedSchemaFieldReference;
-    references: BasedSchemaFieldReferences;
-    text: BasedSchemaFieldText;
-    cardinality: BasedSchemaFieldCardinality;
-    any: BasedSchemaFieldAny;
-};
-export type BasedSchemaField = BasedSchemaFields[keyof BasedSchemaFields] | (BasedSchemaFieldShared & {
-    type?: '';
-    isRequired?: boolean;
-    $ref: string;
-});
-export type BasedSchemaType = {
-    directory?: string;
-    fields: {
-        [name: string]: BasedSchemaField;
-    };
-    title?: string;
-    description?: string;
-    prefix?: BasedSchemaTypePrefix;
-    examples?: any[];
-    required?: string[];
-    $defs?: {
-        [key: string]: BasedSchemaField;
-    };
-    $delete?: boolean;
-};
-export type BasedSchema = {
-    language: BasedSchemaLanguage;
-    translations?: BasedSchemaLanguage[];
-    languageFallbacks?: Partial<Record<BasedSchemaLanguage, BasedSchemaLanguage[]>>;
-    root: BasedSchemaType;
-    $defs: {
-        [name: string]: BasedSchemaField;
-    };
-    types: {
-        [type: string]: BasedSchemaType;
-    };
-    prefixToTypeMapping: {
-        [prefix: string]: string;
-    };
-};
-export type BasedSchemaTypePartial = PartialDeep<BasedSchemaType>;
-export type BasedSchemaFieldPartial = PartialDeep<BasedSchemaField>;
-export type BasedSchemaPartial = PartialDeep<BasedSchema>;
-export type BasedSetTarget = {
-    type: string;
-    $alias?: string;
-    $id?: string;
-    schema: BasedSchema;
-    $merge?: boolean;
-    $language?: BasedSchemaLanguage;
-    required: (number | string)[][];
-    collected: BasedSchemaCollectProps[];
-    errors: {
-        code: ParseError;
-        path: Path;
-    }[];
-};
-export type BasedSchemaCollectProps = ArgsClass<BasedSetTarget> & {
-    root: ArgsClass<BasedSetTarget> & {
-        typeSchema: BasedSchemaType;
-    };
-};

package/dist/src/types.js

@@ -1,113 +0,0 @@
-import { languages as allLanguages } from './languages.js';
-// Schema type
-// inspiration from https://json-schema.org/understanding-json-schema/index.html
-// but added a few extra types
-//   reference
-//   references
-//   set
-//   record
-// https://json-schema.org/learn/examples/geographical-location.schema.json
-// contentSchema can be used for JSON types as well
-// contentSchema can be used for reference / refrences
-// TODO parser / validator / parseOut / parseIn (parsIn after validator)
-// for refs etc check https://json-schema.org/understanding-json-schema/structuring.html#defs
-export const basedSchemaFieldTypes = [
-    'array',
-    'object',
-    'record',
-    'set',
-    'string',
-    'boolean',
-    'number',
-    'json',
-    'integer',
-    'timestamp',
-    'created',
-    'updated',
-    'reference',
-    'references',
-    'text',
-    'enum',
-    'cardinality',
-    'any',
-];
-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',
-    'basedType',
-];
-//# sourceMappingURL=types.js.map

package/dist/src/updateSchema.d.ts

@@ -1,2 +0,0 @@
-import { BasedSchema, BasedSchemaPartial } from './types.js';
-export declare const updateSchema: (_newSchema: BasedSchemaPartial, oldSchema?: BasedSchema) => Promise<BasedSchema>;

package/dist/src/updateSchema.js

@@ -1,12 +0,0 @@
-export const updateSchema = async (_newSchema, oldSchema = {
-    $defs: {},
-    types: {},
-    language: 'en',
-    root: { fields: {} },
-    prefixToTypeMapping: {},
-}) => {
-    // add sha
-    // put isRequired on the new schema in REQUIRED arrays
-    return oldSchema;
-};
-//# sourceMappingURL=updateSchema.js.map

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

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

package/dist/src/validateSchema/basedSchemaTypeValidator.js

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

@@ -1,27 +0,0 @@
-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 {};