@based/schema 2.6.0 → 2.7.1

package/dist/test/validateSchema/basic.js

@@ -0,0 +1,94 @@
+import anyTest from 'ava';
+import { validateSchema } from '../../src/validateSchema/index.js';
+import { ParseError } from '../../src/error.js';
+const test = anyTest;
+test('invalid properties in schema root should fail', async (t) => {
+    // @ts-ignore
+    t.deepEqual(await validateSchema({ invalidProperty: true }), {
+        errors: [{ code: ParseError.invalidProperty, path: ['invalidProperty'] }],
+    });
+});
+test('root', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            wawa: true,
+        },
+    }), {
+        errors: [{ code: ParseError.invalidProperty, path: ['root', 'wawa'] }],
+    });
+    for (const key of ['directory', 'title', 'description']) {
+        const result = await validateSchema({
+            root: {
+                // @ts-ignore
+                [key]: true,
+            },
+        });
+        t.deepEqual(result, {
+            errors: [{ code: ParseError.incorrectFormat, path: ['root', key] }],
+        });
+    }
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            fields: 'wa',
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', 'fields'] }],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            prefix: 'wa',
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', 'prefix'] }],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            prefix: true,
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', 'prefix'] }],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            prefix: 'ro',
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            required: ['astring'],
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            required: 'anotherString',
+        },
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['root', 'required'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            $delete: true,
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            $delete: 'aString',
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', '$delete'] }],
+    });
+});
+//# sourceMappingURL=basic.js.map

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

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

package/dist/test/validateSchema/fields.js

@@ -0,0 +1,436 @@
+import anyTest from 'ava';
+import { validateSchema } from '../../src/validateSchema/index.js';
+import { ParseError } from '../../src/error.js';
+const test = anyTest;
+test('shared', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    wawa: true,
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['root', 'fields', 'stringField', 'wawa'],
+            },
+        ],
+    }, 'invalid property');
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    hooks: { hook: 'aHook' },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    hooks: [
+                        { hook: 'aHook', interval: 1000 },
+                        { hook: 'anotherHook', interval: 2000 },
+                    ],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    hooks: true,
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'stringField', 'hooks'],
+            },
+        ],
+    }, 'hooks format is wrong');
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    hooks: {
+                        hook: 'aHook',
+                        // @ts-ignore
+                        interval: '2000',
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'stringField', 'hooks', 'interval'],
+            },
+        ],
+    }, 'hooks format is wrong');
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    hooks: [
+                        { hook: 'aHook', interval: 1000 },
+                        // @ts-ignore
+                        { hook: 'anotherHook', interval: '2000' },
+                    ],
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'stringField', 'hooks', '1', 'interval'],
+            },
+        ],
+    }, 'hooks format is wrong');
+});
+test('string', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        types: {
+            aType: {
+                fields: {
+                    stringField: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    values: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['root', 'fields', 'stringField', 'values'],
+            },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        types: {
+            aType: {
+                fields: {
+                    stringField: {
+                        type: 'string',
+                        // @ts-ignore
+                        values: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['types', 'aType', 'fields', 'stringField', 'values'],
+            },
+        ],
+    });
+});
+test('objects', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                objectField: {
+                    type: 'object',
+                    properties: {
+                        aStringField: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                objectField: {
+                    type: 'object',
+                    properties: {
+                        aStringField: {
+                            // @ts-ignore
+                            wawa: true,
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'objectField',
+                    'properties',
+                    'aStringField',
+                    'wawa',
+                ],
+            },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                objectField: {
+                    type: 'object',
+                    properties: {
+                        anotherObjectField: {
+                            type: 'object',
+                            properties: {
+                                aWrongObjectField: {
+                                    type: 'object',
+                                    // @ts-ignore
+                                    values: { type: 'string' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'objectField',
+                    'properties',
+                    'anotherObjectField',
+                    'properties',
+                    'aWrongObjectField',
+                    'values',
+                ],
+            },
+        ],
+    });
+});
+test('records', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                recordField: {
+                    type: 'record',
+                    values: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                recordField: {
+                    type: 'record',
+                    values: {
+                        type: 'object',
+                        properties: {
+                            aWrongObjectField: {
+                                type: 'object',
+                                // @ts-ignore
+                                values: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'recordField',
+                    'values',
+                    'properties',
+                    'aWrongObjectField',
+                    'values',
+                ],
+            },
+        ],
+    });
+});
+test('arrays', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                arrayField: {
+                    type: 'array',
+                    values: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                arrayField: {
+                    type: 'array',
+                    values: {
+                        type: 'object',
+                        properties: {
+                            aWrongObjectField: {
+                                type: 'object',
+                                // @ts-ignore
+                                values: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'arrayField',
+                    'values',
+                    'properties',
+                    'aWrongObjectField',
+                    'values',
+                ],
+            },
+        ],
+    });
+});
+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/languages.d.ts

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

package/dist/test/validateSchema/languages.js

@@ -0,0 +1,124 @@
+import anyTest from 'ava';
+import { validateSchema } from '../../src/validateSchema/index.js';
+import { ParseError } from '../../src/error.js';
+const test = anyTest;
+test('should not allow non object schemas', async (t) => {
+    t.deepEqual(await validateSchema(undefined), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+    t.deepEqual(await validateSchema(null), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+    // @ts-ignore
+    t.deepEqual(await validateSchema('this is a string'), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+    // @ts-ignore
+    t.deepEqual(await validateSchema(1), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+});
+test('`languages` property', async (t) => {
+    t.deepEqual(await validateSchema({ language: 'en' }), {
+        valid: true,
+    });
+    // @ts-ignore
+    t.deepEqual(await validateSchema({ language: 'xx' }), {
+        errors: [{ code: ParseError.languageNotSupported, path: ['language'] }],
+    });
+});
+test('`translations` property', async (t) => {
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        // @ts-ignore
+        translations: 'de',
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['translations'] }],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        // @ts-ignore
+        translations: ['pt', 'xx'],
+    }), {
+        errors: [
+            { code: ParseError.languageNotSupported, path: ['translations'] },
+        ],
+    });
+});
+test('`languageFallbacks` property', async (t) => {
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            fr: ['en'],
+            pt: ['fr', 'pt'],
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        // @ts-ignore
+        languageFallbacks: 'pt',
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        // @ts-ignore
+        languageFallbacks: ['pt'],
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            fr: ['en'],
+            // @ts-ignore
+            pt: ['xx', 'pt'],
+        },
+    }), {
+        errors: [
+            { code: ParseError.noLanguageFound, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            // @ts-ignore
+            fr: 'en',
+        },
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            fr: ['en'],
+            // @ts-ignore
+            xx: ['fr', 'pt'],
+        },
+    }), {
+        errors: [
+            { code: ParseError.noLanguageFound, path: ['languageFallbacks'] },
+        ],
+    });
+});
+//# sourceMappingURL=languages.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.6.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/validateSchema.d.ts

@@ -1,4 +0,0 @@
-import { BasedSchemaPartial, BasedSchemaFieldPartial, BasedSchemaTypePartial } from './types.js';
-export declare const validateType: (_fromSchema: BasedSchemaPartial, typeName: string, type: BasedSchemaTypePartial) => void;
-export declare const validateField: (_fromSchema: BasedSchemaPartial, _path: string[], _field: BasedSchemaFieldPartial) => void;
-export declare const validateSchema: (schema: BasedSchemaPartial) => BasedSchemaPartial;