@based/schema 2.7.0 → 3.0.0

package/dist/src/compat/index.js

@@ -1,3 +1,203 @@
-export * from './newToOld.js';
-export * from './oldToNew.js';
+const oldToNewType = {
+    id: { type: 'string', format: 'basedId' },
+    int: { type: 'integer' },
+    url: { type: 'string', format: 'URL' },
+    email: { type: 'string', format: 'email' },
+    float: { type: 'number' },
+    phone: { type: 'string', format: 'mobilePhone' },
+    digest: { type: 'string', format: 'strongPassword' },
+};
+const newToOldType = {
+    mobilePhone: { type: 'phone' },
+    basedId: { type: 'id' },
+    integer: { type: 'int' },
+    URL: { type: 'url' },
+    email: { type: 'email' },
+    strongPassword: { type: 'digest' },
+};
+const convertNewToOldMeta = (props) => {
+    let meta;
+    for (const i in props) {
+        if (i[0] !== '$') {
+            const v = props[i];
+            meta ??= {};
+            if (i === 'display' && v === 'bytes') {
+                meta.format = v;
+            }
+            else if (i === 'title') {
+                meta.name = v;
+            }
+            else {
+                meta[i] = v;
+            }
+        }
+    }
+    return meta;
+};
+const convertOldToNewMeta = (props) => {
+    const meta = {};
+    for (const i in props) {
+        const v = props[i];
+        if (i === 'format' && v === 'bytes') {
+            meta.display = 'bytes';
+        }
+        else if (i === 'name') {
+            meta.title = v;
+        }
+        else {
+            meta[i] = v;
+        }
+    }
+    return meta;
+};
+const convertNewFieldToOldField = (newField) => {
+    // @ts-ignore
+    const { type, properties, values, items, ...props } = newField;
+    const meta = convertNewToOldMeta(props);
+    // @ts-ignore
+    const overwrite = newToOldType[type] || newToOldType[props.format];
+    const oldField = overwrite
+        ? { ...overwrite }
+        : {
+            type,
+        };
+    if (meta) {
+        oldField.meta = meta;
+    }
+    if (properties) {
+        // @ts-ignore
+        oldField.properties = {};
+        for (const key in properties) {
+            // @ts-ignore
+            oldField.properties[key] = convertNewFieldToOldField(properties[key]);
+        }
+    }
+    if (values) {
+        // @ts-ignore
+        oldField.values = convertNewFieldToOldField(values);
+    }
+    if (items) {
+        // @ts-ignore
+        oldField.items = convertNewFieldToOldField(items);
+    }
+    return oldField;
+};
+const convertNewTypeToOldType = (newType) => {
+    const { prefix, fields, ...props } = newType;
+    const oldType = {};
+    const meta = convertNewToOldMeta(props);
+    if (prefix) {
+        oldType.prefix = prefix;
+    }
+    if (meta) {
+        oldType.meta = meta;
+    }
+    if (fields) {
+        oldType.fields = {};
+        for (const key in fields) {
+            // @ts-ignore
+            oldType.fields[key] = convertNewFieldToOldField(fields[key]);
+        }
+    }
+    return oldType;
+};
+export const convertNewToOld = (newSchema) => {
+    const { root, types, language, translations, prefixToTypeMapping } = newSchema;
+    const oldSchema = {};
+    if (prefixToTypeMapping) {
+        oldSchema.prefixToTypeMapping = prefixToTypeMapping;
+    }
+    if (language) {
+        oldSchema.languages = [language];
+    }
+    if (translations) {
+        oldSchema.languages ??= [];
+        oldSchema.languages.push(...translations);
+    }
+    if (root) {
+        oldSchema.rootType = convertNewTypeToOldType(root);
+    }
+    if (types) {
+        oldSchema.types = {};
+        for (const key in types) {
+            oldSchema.types[key] = convertNewTypeToOldType(types[key]);
+        }
+    }
+    return oldSchema;
+};
+const convertOldFieldToNewField = (oldField) => {
+    // @ts-ignore
+    const { type, properties, values, items, meta = {} } = oldField;
+    const overwrite = oldToNewType[type] || oldToNewType[meta.format];
+    const newField = overwrite
+        ? {
+            ...overwrite,
+            ...convertOldToNewMeta(meta),
+        }
+        : {
+            type,
+            ...convertOldToNewMeta(meta),
+        };
+    if (properties) {
+        // @ts-ignore
+        newField.properties = {};
+        for (const key in properties) {
+            // @ts-ignore
+            newField.properties[key] = convertOldFieldToNewField(properties[key]);
+        }
+    }
+    if (values) {
+        // @ts-ignore
+        newField.values = convertOldFieldToNewField(values);
+    }
+    if (items) {
+        // @ts-ignore
+        newField.items = convertOldFieldToNewField(items);
+    }
+    return newField;
+};
+const convertOldTypeToNewType = (oldType) => {
+    const { prefix, fields, meta } = oldType;
+    const newType = {
+        fields: {},
+    };
+    if (prefix) {
+        newType.prefix = prefix;
+    }
+    if (meta) {
+        Object.assign(newType, convertOldToNewMeta(meta));
+    }
+    if (fields) {
+        for (const key in fields) {
+            newType.fields[key] = convertOldFieldToNewField(fields[key]);
+        }
+    }
+    return newType;
+};
+export const convertOldToNew = (oldSchema) => {
+    const { rootType, types, languages, prefixToTypeMapping } = oldSchema;
+    const newSchema = {};
+    if (prefixToTypeMapping) {
+        newSchema.prefixToTypeMapping = prefixToTypeMapping;
+    }
+    if (languages?.length) {
+        // @ts-ignore
+        newSchema.language = languages[0];
+        const translations = languages.slice(1);
+        if (translations.length) {
+            // @ts-ignore
+            newSchema.translations = translations;
+        }
+    }
+    if (rootType) {
+        newSchema.root = convertOldTypeToNewType(rootType);
+    }
+    if (types) {
+        newSchema.types = {};
+        for (const key in types) {
+            newSchema.types[key] = convertOldTypeToNewType(types[key]);
+        }
+    }
+    return newSchema;
+};
 //# sourceMappingURL=index.js.map

package/dist/src/compat/newToOld.d.ts

@@ -1,3 +1,3 @@
-import { BasedSchema } from '../types.js';
 import { BasedOldSchema } from './oldSchemaType.js';
-export declare const convertNewToOld: (schema: BasedSchema) => Partial<BasedOldSchema>;
+import { BasedSchemaPartial } from '../types.js';
+export declare const convertNewToOld: (schema: BasedSchemaPartial) => Partial<BasedOldSchema>;

package/dist/src/compat/newToOld.js

@@ -1,5 +1,3 @@
-// import { BasedSchema } from '../types.js'
-// import { BasedOldSchema } from './oldSchemaType.js'
 const metaChecker = (field) => {
     return (field === 'validation' ||
         // field === 'format' ||
@@ -35,9 +33,6 @@ const metaChecker = (field) => {
         field === '$delete' ||
         field === 'display');
 };
-const excludedFields = (field) => {
-    return field === 'language' || field === 'translations' || field === '$defs';
-};
 const DEFAULT_FIELDS = {
 // id: { type: 'string' },
 // createdAt: { type: 'timestamp' },
@@ -67,7 +62,7 @@ const metaParser = (obj) => {
             }
         }
     }
-    return Object.keys({ meta: tmp }.meta).length > 0 ? { meta: tmp } : null;
+    return Object.keys(tmp).length > 0 ? { meta: tmp } : null;
 };
 const migrateField = (field) => {
     if (field?.type === 'object') {
@@ -180,9 +175,11 @@ const migrateTypes = (oldSchema) => {
             const type = oldSchema.types[key];
             result.types[key] = {
                 ...metaParser(type),
-                prefix: type.prefix,
                 fields: migrateFields(type.fields),
             };
+            if (type.prefix) {
+                result.types[key].prefix = type.prefix;
+            }
         }
     }
     return result;
@@ -204,8 +201,16 @@ const convertRoot = (schema) => {
 };
 export const convertNewToOld = (schema) => {
     const tmpSchema = migrateTypes(schema);
-    tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
-    tmpSchema.languages = [schema.language, ...schema?.translations];
+    if (schema.prefixToTypeMapping) {
+        tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
+    }
+    tmpSchema.languages = [];
+    if (schema.language) {
+        tmpSchema.languages.push(schema.language);
+    }
+    if (schema.translations) {
+        tmpSchema.languages.push(...schema.translations);
+    }
     tmpSchema.rootType = convertRoot(schema);
     delete tmpSchema.root;
     return tmpSchema;

package/dist/src/compat/oldSchemaType.d.ts

@@ -1,5 +1,5 @@
 type FieldType = 'float' | 'boolean' | 'number' | 'int' | 'string' | 'text' | 'id' | 'digest' | 'url' | 'email' | 'phone' | 'geo' | 'type' | 'timestamp';
-type FieldSchemaObject = {
+export type FieldSchemaObject = {
     type: 'object';
     properties: {
         [key: string]: FieldSchema;
@@ -34,13 +34,37 @@ type FieldSchemaOther = {
     meta?: any;
     timeseries?: boolean;
 };
-type FieldSchemaArrayLike = {
+export type FieldSchemaArrayLike = {
     type: 'set' | 'array';
     items: FieldSchema;
     meta?: any;
     timeseries?: boolean;
 };
-type FieldSchema = FieldSchemaObject | FieldSchemaRecord | FieldSchemaArrayLike | FieldSchemaJson | FieldSchemaReferences | FieldSchemaOther;
+export type FieldSchema = FieldSchemaObject | FieldSchemaRecord | FieldSchemaArrayLike | FieldSchemaJson | FieldSchemaReferences | FieldSchemaOther;
+type FieldInputSchemaArrayLike = {
+    type: 'set' | 'array';
+    items: FieldInputSchema;
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldInputSchemaRecord = {
+    type: 'record';
+    values: FieldInputSchema;
+    meta?: any;
+    timeseries?: boolean;
+};
+export type FieldInputSchemaObject = {
+    type: 'object';
+    properties: {
+        [key: string]: FieldInputSchema;
+    };
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldInputSchema = FieldSchema | FieldInputSchemaArrayLike | FieldInputSchemaRecord | FieldInputSchemaObject | DeleteField;
+type DeleteField = {
+    $delete: boolean;
+};
 type Fields = Record<string, FieldSchema>;
 type HierarchySchema = false | {
     [key: string]: false | {
@@ -49,7 +73,7 @@ type HierarchySchema = false | {
         includeAncestryWith: string[];
     };
 };
-type TypeSchema = {
+export type TypeSchema = {
     prefix?: string;
     hierarchy?: HierarchySchema;
     fields?: Fields;

package/dist/src/compat/oldToNew.d.ts

@@ -1,3 +1,3 @@
 import { BasedSchema } from '../types.js';
 import { BasedOldSchema } from './oldSchemaType.js';
-export declare const convertOldToNew: (oldSchema: BasedOldSchema) => BasedSchema;
+export declare const convertOldToNew: (oldSchema: Partial<BasedOldSchema>) => BasedSchema;

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

@@ -20,13 +20,13 @@ 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 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.values,
+            fieldSchema: args.fieldSchema.items,
             collect: (nArgs) => {
                 const p = nArgs.path.slice(args.path.length);
                 // @ts-ignore
@@ -77,7 +77,7 @@ const operations = {
         await args.parse({
             key: value.$assign.$idx,
             value: value.$assign.$value,
-            fieldSchema: args.fieldSchema.values,
+            fieldSchema: args.fieldSchema.items,
         });
     },
 };
@@ -95,7 +95,7 @@ export const array = async (args) => {
             q.push(args.parse({
                 key: i,
                 value: args.value[i],
-                fieldSchema: args.fieldSchema.values,
+                fieldSchema: args.fieldSchema.items,
             }));
         }
         await Promise.all(q);

package/dist/src/types.d.ts

@@ -114,7 +114,7 @@ export type BasedSchemaFieldRecord = {
 } & BasedSchemaFieldShared;
 export type BasedSchemaFieldArray = {
     type: 'array';
-    values: BasedSchemaField;
+    items: BasedSchemaField;
 } & BasedSchemaFieldShared;
 export type BasedSchemaFieldSet = {
     type: 'set';

package/dist/src/validateSchema/fieldValidators.js

@@ -4,7 +4,7 @@ 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';
+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 [
@@ -14,7 +14,7 @@ export const mustBeField = (value, path, newSchema, oldSchema, options) => {
             },
         ];
     }
-    const type = value.type;
+    const type = value.hasOwnProperty('enum') ? 'enum' : value.type;
     if ((options?.limitTo === 'primitives' &&
         ![
             'string',
@@ -75,6 +75,12 @@ export const mustBeField = (value, path, newSchema, oldSchema, options) => {
         case 'set':
             validator = basedSchemaFieldSetValidator;
             break;
+        case 'reference':
+            validator = basedSchemaFieldReferenceValidator;
+            break;
+        case 'references':
+            validator = basedSchemaFieldReferencesValidator;
+            break;
         default:
             validator = basedSchemaFieldSharedValidator;
             break;
@@ -214,7 +220,9 @@ export const basedSchemaStringValidator = {
 };
 export const basedSchemaFieldEnumValidator = {
     ...basedSchemaFieldSharedValidator,
-    enum: {},
+    enum: {
+        validator: mustBeArray,
+    },
 };
 export const basedSchemaFieldCardinalityValidator = {
     ...basedSchemaFieldSharedValidator,
@@ -313,7 +321,7 @@ export const basedSchemaFieldRecordValidator = {
 };
 export const basedSchemaFieldArrayValidator = {
     ...basedSchemaFieldSharedValidator,
-    values: {
+    items: {
         validator: mustBeField,
     },
 };

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

@@ -3,6 +3,10 @@ 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[];

package/dist/src/validateSchema/utils.js

@@ -7,6 +7,14 @@ export const mustBeString = (value, path) => typeof value === 'string'
             path,
         },
     ];
+export const mustBeArray = (value, path) => Array.isArray(value)
+    ? []
+    : [
+        {
+            code: ParseError.incorrectFormat,
+            path,
+        },
+    ];
 export const mustBeStringArray = (value, path) => Array.isArray(value) && value.every((i) => typeof i === 'string')
     ? []
     : [

package/dist/test/array.js

@@ -8,13 +8,13 @@ const schema = {
             fields: {
                 arrNum: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'number',
                     },
                 },
                 objArray: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'object',
                         properties: {
                             snurp: {
@@ -25,13 +25,13 @@ const schema = {
                 },
                 arrStr: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'string',
                     },
                 },
                 intarray: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'integer',
                     },
                 },

package/dist/test/compat.js

@@ -1,15 +1,51 @@
 import test from 'ava';
-// TODO: maybe nice to use for validate import { newSchemas } from './data/newSchemas.js'
+import { newSchemas } from './data/newSchemas.js';
 import { oldSchemas } from './data/oldSchemas.js';
 import { convertNewToOld, convertOldToNew, validateSchema, } from '../src/index.js';
+const addStandardMetaToOld = (obj) => {
+    if (obj && typeof obj === 'object') {
+        if (obj.type === 'id') {
+            obj.meta ??= {};
+            obj.meta.format = 'basedId';
+        }
+        else if (obj.type === 'email') {
+            obj.meta ??= {};
+            obj.meta.format = 'email';
+        }
+        else if (obj.type === 'digest') {
+            obj.meta ??= {};
+            obj.meta.format = 'strongPassword';
+        }
+        else if (obj.type === 'url') {
+            obj.meta ??= {};
+            obj.meta.format = 'URL';
+        }
+        else if (obj.type === 'phone') {
+            obj.meta ??= {};
+            obj.meta.format = 'mobilePhone';
+        }
+        for (const i in obj) {
+            addStandardMetaToOld(obj[i]);
+        }
+    }
+};
 test('old schema compat mode', async (t) => {
     for (let i = 0; i < oldSchemas.length - 1; i++) {
-        // for (let i = 0; i < 1; i++) {
         const oldSchema = oldSchemas[i];
         const newSchema = convertOldToNew(oldSchema);
         const validation = await validateSchema(newSchema);
         t.true(validation.valid);
+        addStandardMetaToOld(oldSchema);
         t.deepEqual(oldSchema, convertNewToOld(newSchema), `Schema conversion oldSchemas index ${i}`);
     }
 });
+test('new schema compat mode', async (t) => {
+    for (let i = 0; i < newSchemas.length - 1; i++) {
+        const newSchema = newSchemas[i];
+        const validation = await validateSchema(newSchema);
+        const oldSchema = convertNewToOld(newSchema);
+        t.true(validation.valid);
+        t.deepEqual(newSchema, convertOldToNew(oldSchema), `Schema conversion newSchemas index ${i}`);
+    }
+});
 //# sourceMappingURL=compat.js.map

package/dist/test/data/newSchemas.d.ts

@@ -1,2 +1,2 @@
-import { BasedSchema } from '../../src/types.js';
-export declare const newSchemas: BasedSchema[];
+import { BasedSchemaPartial } from '../../src/types.js';
+export declare const newSchemas: BasedSchemaPartial[];