@based/schema 2.7.0 → 2.7.1

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

@@ -67,7 +67,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') {
@@ -205,7 +205,13 @@ const convertRoot = (schema) => {
 export const convertNewToOld = (schema) => {
     const tmpSchema = migrateTypes(schema);
     tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
-    tmpSchema.languages = [schema.language, ...schema?.translations];
+    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/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/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,

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/compat.js

@@ -1,5 +1,6 @@
 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';
 test('old schema compat mode', async (t) => {
@@ -12,4 +13,15 @@ test('old schema compat mode', async (t) => {
         t.deepEqual(oldSchema, convertNewToOld(newSchema), `Schema conversion oldSchemas index ${i}`);
     }
 });
+test.failing('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}`);
+    }
+});
 //# 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[];

package/dist/test/data/newSchemas.js

@@ -1,4 +1,240 @@
+const defaultFields = {
+    createdAt: {
+        readOnly: true,
+        type: 'timestamp',
+    },
+    updatedAt: {
+        readOnly: true,
+        type: 'timestamp',
+    },
+};
+const testSchema = {
+    language: 'en',
+    translations: ['pt', 'es'],
+    root: {
+        fields: {
+            currentSeason: {
+                type: 'reference',
+                title: 'Currently active season',
+            },
+        },
+    },
+    types: {
+        file: {
+            fields: {
+                ...defaultFields,
+                width: {
+                    type: 'number',
+                },
+                height: {
+                    type: 'number',
+                },
+            },
+        },
+        country: {
+            prefix: 'co',
+            title: 'Country',
+            description: 'This is the country',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                    title: 'Country code',
+                },
+                title: {
+                    type: 'text',
+                    title: 'Translated country name',
+                },
+                circleImage: {
+                    type: 'reference',
+                    title: 'Circular flag image',
+                },
+                heartImage: {
+                    type: 'reference',
+                    title: 'Heart-shaped flag image',
+                },
+            },
+        },
+        season: {
+            prefix: 'se',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                    title: 'Season name',
+                },
+                winner: {
+                    type: 'reference',
+                    allowedTypes: ['contestant'],
+                },
+                countries: {
+                    type: 'references',
+                    title: 'Participating countries',
+                },
+            },
+        },
+        episode: {
+            prefix: 'ep',
+            fields: {
+                ...defaultFields,
+                episodeType: {
+                    type: 'string', // redemption, grandFinal, nationalFinal or nationalQualifier
+                    title: 'Type of episode',
+                },
+                title: {
+                    type: 'text',
+                    title: 'Episode title',
+                },
+                image: {
+                    type: 'reference',
+                    allowedTypes: ['file'],
+                },
+                startTime: {
+                    type: 'timestamp',
+                    title: 'Start time',
+                },
+                endTime: {
+                    type: 'timestamp',
+                    title: 'End time',
+                },
+                producer: {
+                    type: 'reference',
+                    allowedTypes: ['broadcaster'],
+                },
+                distributors: {
+                    type: 'references',
+                    allowedTypes: ['broadcaster'],
+                },
+            },
+        },
+        votingWindow: {
+            prefix: 'vo',
+            fields: {
+                ...defaultFields,
+                startTime: {
+                    type: 'timestamp',
+                },
+                closeTime: {
+                    type: 'timestamp',
+                },
+                endTime: {
+                    type: 'timestamp',
+                },
+            },
+        },
+        contestant: {
+            prefix: 'ct',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                },
+                song: {
+                    type: 'string',
+                },
+                songUrl: {
+                    type: 'string',
+                    format: 'URL',
+                },
+                writer: {
+                    type: 'string',
+                },
+                image: {
+                    type: 'reference',
+                    allowedTypes: ['file'],
+                },
+                content: {
+                    type: 'text',
+                    format: 'html',
+                },
+            },
+        },
+        broadcaster: {
+            prefix: 'br',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                },
+                email: {
+                    type: 'string',
+                    format: 'email',
+                },
+                image: {
+                    type: 'reference',
+                    allowedTypes: ['file'],
+                },
+            },
+        },
+        feed: {
+            prefix: 'fe',
+            fields: {
+                ...defaultFields,
+                title: {
+                    type: 'text',
+                },
+                content: {
+                    type: 'text',
+                    format: 'html',
+                },
+                imageUrl: {
+                    type: 'string',
+                    format: 'URL',
+                },
+                videoUrl: {
+                    type: 'string',
+                    format: 'URL',
+                },
+                url: {
+                    type: 'string',
+                    format: 'URL',
+                },
+            },
+        },
+        user: {
+            prefix: 'us',
+            fields: {
+                ...defaultFields,
+                name: { type: 'string' },
+                language: { type: 'string' },
+                notify: { type: 'boolean' },
+                country: { type: 'string' },
+                customerId: {
+                    // stripe customerId
+                    type: 'string',
+                },
+                credits: {
+                    type: 'record',
+                    values: {
+                        type: 'object',
+                        properties: {
+                            purchased: {
+                                type: 'number',
+                            },
+                            earned: {
+                                type: 'number',
+                            },
+                        },
+                    },
+                },
+                voteHistory: {
+                    type: 'record',
+                    values: {
+                        type: 'record',
+                        values: {
+                            type: 'record',
+                            values: {
+                                type: 'number',
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
 export const newSchemas = [
+    testSchema,
     {
         types: {
             thing: {
@@ -11,6 +247,10 @@ export const newSchemas = [
             bla: {
                 prefix: 'bl',
                 fields: {
+                    createdAt: {
+                        type: 'timestamp',
+                        readOnly: true,
+                    },
                     enum: {
                         enum: ['tony', 'jim'],
                     },
@@ -109,6 +349,7 @@ export const newSchemas = [
         },
         $defs: {},
         language: 'en',
+        translations: [],
         root: {
             fields: {},
         },

package/dist/test/validateSchema/fields.js

@@ -363,4 +363,74 @@ test('arrays', async (t) => {
         ],
     });
 });
+test('enum', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: ['one', 'two'],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: [1, 2],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: [{ one: 'one' }, { two: 'two' }],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    // @ts-ignore
+                    enum: 'invalidEnum',
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'enumField', 'enum'],
+            },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: ['one', 'two'],
+                    // @ts-ignore
+                    invalidProperty: 'invalid',
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['root', 'fields', 'enumField', 'invalidProperty'],
+            },
+        ],
+    });
+});
 //# sourceMappingURL=fields.js.map

package/dist/test/validateSchema/realWorld.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/validateSchema/realWorld.js

@@ -0,0 +1,13 @@
+import test from 'ava';
+import { newSchemas } from '../data/newSchemas.js';
+import { validateSchema } from '../../src/index.js';
+test('these schemas should work', async (t) => {
+    await Promise.all(newSchemas.map(async (validSchema) => {
+        const validation = await validateSchema(validSchema);
+        if (!validation.valid) {
+            console.dir(validation.errors, { depth: null });
+        }
+        t.true(validation.valid);
+    }));
+});
+//# sourceMappingURL=realWorld.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "license": "MIT",
   "main": "dist/src/index.js",
   "files": [
@@ -26,7 +26,8 @@
   "ava": {
     "timeout": "2m",
     "files": [
-      "./dist/test/*.js"
+      "./dist/test/*.js",
+      "./dist/test/validateSchema/*.js"
     ]
   },
   "devDependencies": {
@@ -35,6 +36,6 @@
     "ts-node": "10.9.1",
     "typescript": "^5.1.6",
     "rimraf": "^3.0.2",
-    "ava": "5.3.1"
+    "ava": "6.1.1"
   }
 }

package/dist/src/compat/Untitled-1.d.ts

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

package/dist/src/compat/Untitled-1.js

@@ -1,205 +0,0 @@
-const metaChecker = (field) => {
-    return (field === 'validation' ||
-        field === 'format' ||
-        field === 'index' ||
-        field === 'description' ||
-        field === 'title' ||
-        field === 'examples' ||
-        field === 'ui' ||
-        field === 'isRequired' ||
-        field === 'title' ||
-        field === 'description' ||
-        field === 'index' ||
-        field === 'readOnly' ||
-        field === 'writeOnly' ||
-        field === '$comment' ||
-        field === 'examples' ||
-        field === 'default' ||
-        field === 'customValidator' ||
-        field === 'value' ||
-        field === 'path' ||
-        field === 'target' ||
-        field === 'minLength' ||
-        field === 'maxLength' ||
-        field === 'contentMediaEncoding' ||
-        field === 'pattern' ||
-        field === 'display' ||
-        field === 'multiline' ||
-        field === 'multipleOf' ||
-        field === 'minimum' ||
-        field === 'maximum' ||
-        field === 'exclusiveMaximum' ||
-        field === 'exclusiveMinimum' ||
-        field === '$delete');
-};
-const excludedFields = (field) => {
-    return field === 'language' || field === 'translations' || field === '$defs';
-};
-const DEFAULT_FIELDS = {
-    id: { type: 'string' },
-    createdAt: { type: 'timestamp' },
-    updatedAt: { type: 'timestamp' },
-    type: { type: 'string' },
-    parents: { type: 'references' },
-    children: { type: 'references' },
-    ancestors: { type: 'references' },
-    descendants: { type: 'references' },
-    aliases: {
-        type: 'set',
-        items: { type: 'string' },
-    },
-};
-const metaParser = (obj) => {
-    const tmp = {};
-    for (const i in obj) {
-        if (metaChecker(i)) {
-            if (i === 'title') {
-                tmp.name = obj[i];
-            }
-            else {
-                tmp[i] = obj[i];
-            }
-        }
-    }
-    return Object.keys({ meta: tmp }.meta).length > 0 ? { meta: tmp } : null;
-};
-const migrateField = (oldField) => {
-    switch (oldField?.type) {
-        case 'object':
-            return {
-                ...metaParser(oldField),
-                type: 'object',
-                properties: migrateFields(oldField.properties, true),
-            };
-        case 'json':
-            return {
-                ...oldField,
-                ...metaParser(oldField),
-                type: 'json',
-            };
-        case 'array':
-            const values = migrateField(oldField.items);
-            if (!values) {
-                return null;
-            }
-            return {
-                ...metaParser(oldField),
-                type: 'array',
-                items: values,
-            };
-        case 'set':
-            return {
-                ...metaParser(oldField),
-                type: 'set',
-                items: migrateField(oldField.items),
-            };
-        case 'record':
-            return {
-                ...metaParser(oldField),
-                type: 'record',
-                values: migrateField(oldField.values),
-            };
-        case 'reference':
-        case 'references':
-            return {
-                ...metaParser(oldField),
-                type: oldField.type,
-                ...(oldField.bidirectional
-                    ? { bidirectional: oldField.bidirectional }
-                    : null),
-            };
-        case 'float':
-            return {
-                ...metaParser(oldField),
-                type: 'number',
-            };
-        case 'int':
-            return {
-                ...metaParser(oldField),
-                type: 'integer',
-            };
-        case 'digest':
-            return {
-                format: 'strongPassword',
-                type: 'string',
-            };
-        case 'id':
-            return {
-                ...metaParser(oldField),
-                type: 'string',
-            };
-        case 'url':
-            return {
-                ...metaParser(oldField),
-                format: 'URL',
-                type: 'string',
-            };
-        case 'email':
-            return {
-                ...metaParser(oldField),
-                type: 'string',
-            };
-        case 'phone':
-            return {
-                format: 'mobilePhone',
-                type: 'string',
-            };
-        case 'geo':
-            return {
-                format: 'latLong',
-                type: 'string',
-            };
-        case 'type':
-            return {
-                ...metaParser(oldField),
-                type: 'string',
-            };
-        default:
-            return {
-                ...metaParser(oldField),
-                type: oldField.type,
-            };
-    }
-};
-const migrateFields = (oldFields, recursing = false) => {
-    const result = {};
-    if (oldFields) {
-        for (const key in oldFields) {
-            if (oldFields.hasOwnProperty(key)) {
-                if (!recursing && Object.keys(DEFAULT_FIELDS).includes(key)) {
-                    continue;
-                }
-                const field = migrateField(oldFields[key]);
-                if (!field) {
-                    continue;
-                }
-                result[key] = field;
-            }
-        }
-    }
-    return result;
-};
-const migrateTypes = (oldSchema) => {
-    const result = {
-        types: {},
-    };
-    for (const key in oldSchema.types) {
-        if (oldSchema.types.hasOwnProperty(key)) {
-            const type = oldSchema.types[key];
-            result.types[key] = {
-                ...metaParser(type),
-                prefix: type.prefix,
-                fields: migrateFields(type.fields),
-            };
-        }
-    }
-    return result;
-};
-export const convertNewToOld222 = (schema) => {
-    const tmpSchema = migrateTypes(schema);
-    tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
-    tmpSchema.languages = [schema.language, ...schema?.translations];
-    delete tmpSchema.root;
-    return tmpSchema;
-};
-//# sourceMappingURL=Untitled-1.js.map