@based/schema 2.7.1 → 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.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' },
@@ -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,7 +201,9 @@ const convertRoot = (schema) => {
 };
 export const convertNewToOld = (schema) => {
     const tmpSchema = migrateTypes(schema);
-    tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
+    if (schema.prefixToTypeMapping) {
+        tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
+    }
     tmpSchema.languages = [];
     if (schema.language) {
         tmpSchema.languages.push(schema.language);

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/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

@@ -321,7 +321,7 @@ export const basedSchemaFieldRecordValidator = {
 };
 export const basedSchemaFieldArrayValidator = {
     ...basedSchemaFieldSharedValidator,
-    values: {
+    items: {
         validator: mustBeField,
     },
 };

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,25 +1,49 @@
 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.failing('new schema compat mode', async (t) => {
+test('new schema compat mode', async (t) => {
     for (let i = 0; i < newSchemas.length - 1; i++) {
-        // for (let i = 0; i < 1; i++) {
         const newSchema = newSchemas[i];
         const validation = await validateSchema(newSchema);
         const oldSchema = convertNewToOld(newSchema);
-        console.dir(validation, { depth: null });
         t.true(validation.valid);
         t.deepEqual(newSchema, convertOldToNew(oldSchema), `Schema conversion newSchemas index ${i}`);
     }

package/dist/test/data/newSchemas.js

@@ -251,9 +251,9 @@ export const newSchemas = [
                         type: 'timestamp',
                         readOnly: true,
                     },
-                    enum: {
-                        enum: ['tony', 'jim'],
-                    },
+                    // enum: {
+                    //   enum: ['tony', 'jim'],
+                    // },
                     setOfNumbers: {
                         type: 'set',
                         items: {
@@ -284,7 +284,7 @@ export const newSchemas = [
                             properties: {
                                 bla: {
                                     type: 'array',
-                                    values: {
+                                    items: {
                                         type: 'object',
                                         properties: {
                                             snux: {
@@ -309,7 +309,6 @@ export const newSchemas = [
                 },
             },
         },
-        $defs: {},
         language: 'en',
         translations: ['de', 'nl', 'ro', 'za', 'ae'],
         root: {
@@ -347,9 +346,7 @@ export const newSchemas = [
                 },
             },
         },
-        $defs: {},
         language: 'en',
-        translations: [],
         root: {
             fields: {},
         },
@@ -361,7 +358,6 @@ export const newSchemas = [
     {
         language: 'en',
         translations: ['nl'],
-        $defs: {},
         prefixToTypeMapping: {},
         root: {
             fields: {},
@@ -480,7 +476,7 @@ export const newSchemas = [
                         bidirectional: { fromField: 'usedIn' },
                     },
                     hits: { type: 'number' }, // get a bit more going here maybe? what does this mean
-                    membership: { enum: ['Need membership', 'Free'] },
+                    // membership: { enum: ['Need membership', 'Free'] },
                     location: { type: 'text' }, // or string its just city name or smth
                     bio: { type: 'text', format: 'json' }, //has a href and stuff so aarich text
                     tweet: { type: 'string' }, // ask if it needs translation  // 'The 2009 allocation of solar subsidies in Solvakia "was rigged," say a US cable. PM Fico denies it.',

package/dist/test/rest.js

@@ -46,7 +46,7 @@ const schema = {
                         properties: {
                             bla: {
                                 type: 'array',
-                                values: {
+                                items: {
                                     type: 'object',
                                     properties: {
                                         snux: {

package/dist/test/validateSchema/fields.js

@@ -319,7 +319,7 @@ test('arrays', async (t) => {
             fields: {
                 arrayField: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'string',
                     },
                 },
@@ -333,13 +333,13 @@ test('arrays', async (t) => {
             fields: {
                 arrayField: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'object',
                         properties: {
                             aWrongObjectField: {
                                 type: 'object',
                                 // @ts-ignore
-                                values: { type: 'string' },
+                                items: { type: 'string' },
                             },
                         },
                     },
@@ -354,10 +354,10 @@ test('arrays', async (t) => {
                     'root',
                     'fields',
                     'arrayField',
-                    'values',
+                    'items',
                     'properties',
                     'aWrongObjectField',
-                    'values',
+                    'items',
                 ],
             },
         ],

package/dist/test/walker.js

@@ -45,7 +45,7 @@ const schema = {
                 },
                 intarray: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'integer',
                     },
                 },
@@ -82,7 +82,7 @@ const schema = {
                         properties: {
                             bla: {
                                 type: 'array',
-                                values: {
+                                items: {
                                     type: 'object',
                                     properties: {
                                         snux: {