@contember/engine-content-api 1.1.0-alpha.4 → 1.1.0-alpha.7

package/dist/tests/cases/unit/inputPreValidator.test.js

@@ -1,29 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const input_validation_1 = require("../../../src/input-validation");
 const schema_definition_1 = require("@contember/schema-definition");
@@ -32,8 +13,7 @@ const src_1 = require("../../../src");
 const schema_utils_1 = require("@contember/schema-utils");
 const utils_1 = require("../../src/utils");
 const testUuid_1 = require("../../src/testUuid");
-const assert = __importStar(require("uvu/assert"));
-const uvu_1 = require("uvu");
+const vitest_1 = require("vitest");
 const schema_definition_2 = require("@contember/schema-definition");
 const createDataSelectorMock = (primaryValues, selects) => {
     return (0, utils_1.createMock)({
@@ -43,8 +23,8 @@ const createDataSelectorMock = (primaryValues, selects) => {
             if (!entry) {
                 throw new Error(`Unexpected getPrimaryValue call`);
             }
-            assert.is(entity.name, entry.entity);
-            assert.equal(where, entry.where);
+            vitest_1.assert.deepStrictEqual(entity.name, entry.entity);
+            vitest_1.assert.deepStrictEqual(where, entry.where);
             return entry.result;
         },
         select: async (mapper, entity, where, dependencies) => {
@@ -56,10 +36,10 @@ const createDataSelectorMock = (primaryValues, selects) => {
                 console.log(JSON.stringify({ entity: entity.name, where, dependencies, result: {} }));
                 throw new Error(`Unexpected select call`);
             }
-            assert.is(entity.name, entry.entity);
-            assert.equal(where, entry.where);
+            vitest_1.assert.equal(entity.name, entry.entity);
+            vitest_1.assert.deepStrictEqual(where, entry.where);
             //console.log(JSON.stringify(entry))
-            assert.equal(dependencies, entry.dependencies);
+            vitest_1.assert.deepStrictEqual(dependencies, entry.dependencies);
             return entry.result;
         },
     });
@@ -69,355 +49,355 @@ const createValidator = ({ model, validation, primaryValues, selects, }) => new
     now: () => new Date(),
 }), createDataSelectorMock(primaryValues || [], selects || []));
 const mapper = {};
-const inputPreValidatorTest = (0, uvu_1.suite)('Input pre-validator');
-inputPreValidatorTest('validates implicit rules', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
-        .buildSchema();
-    const validator = createValidator({ model, validation: {} });
-    const result = await validator.validateCreate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {},
-        overRelation: null,
-        path: [],
-        mapper,
+var ViewModelDefinition;
+(function (ViewModelDefinition) {
+    class Book {
+        constructor() {
+            this.title = schema_definition_2.SchemaDefinition.stringColumn();
+            this.stats = schema_definition_2.SchemaDefinition.oneHasOneInverse(BookStats, 'book').notNull();
+        }
+    }
+    ViewModelDefinition.Book = Book;
+    let BookStats = class BookStats {
+        constructor() {
+            this.book = schema_definition_2.SchemaDefinition.oneHasOne(Book, 'stats').notNull();
+            this.foo = schema_definition_2.SchemaDefinition.intColumn();
+        }
+    };
+    BookStats = __decorate([
+        schema_definition_2.SchemaDefinition.View('SELECT 1')
+    ], BookStats);
+    ViewModelDefinition.BookStats = BookStats;
+})(ViewModelDefinition || (ViewModelDefinition = {}));
+(0, vitest_1.describe)('Input pre-validator', () => {
+    (0, vitest_1.it)('validates implicit rules', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
+            .buildSchema();
+        const validator = createValidator({ model, validation: {} });
+        const result = await validator.validateCreate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {},
+            overRelation: null,
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, [
+            {
+                path: [
+                    {
+                        field: 'title',
+                    },
+                ],
+                message: {
+                    text: 'Field is required',
+                },
+            },
+        ]);
     });
-    assert.equal(result, [
-        {
-            path: [
-                {
-                    field: 'title',
+    (0, vitest_1.it)('validates explicit rules', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
+            .buildSchema();
+        const validator = createValidator({
+            model,
+            validation: {
+                Book: {
+                    description: [{ message: { text: 'Minimum length is 10 characters' }, validator: schema_definition_1.InputValidation.rules.minLength(10) }],
                 },
-            ],
-            message: {
-                text: 'Field is required',
             },
-        },
-    ]);
-});
-inputPreValidatorTest('validates explicit rules', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
-        .buildSchema();
-    const validator = createValidator({
-        model,
-        validation: {
-            Book: {
-                description: [{ message: { text: 'Minimum length is 10 characters' }, validator: schema_definition_1.InputValidation.rules.minLength(10) }],
+        });
+        const result = await validator.validateCreate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                title: 'Hello',
+                description: 'World',
             },
-        },
-    });
-    const result = await validator.validateCreate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            title: 'Hello',
-            description: 'World',
-        },
-        overRelation: null,
-        path: [],
-        mapper,
-    });
-    assert.equal(result, [
-        {
-            path: [
-                {
-                    field: 'description',
+            overRelation: null,
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, [
+            {
+                path: [
+                    {
+                        field: 'description',
+                    },
+                ],
+                message: {
+                    text: 'Minimum length is 10 characters',
                 },
-            ],
-            message: {
-                text: 'Minimum length is 10 characters',
             },
-        },
-    ]);
-    const result2 = await validator.validateCreate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            title: 'Hello',
-            description: 'World abcdef',
-        },
-        overRelation: null,
-        path: [],
-        mapper,
-    });
-    assert.equal(result2, []);
-});
-inputPreValidatorTest('dependent rules invalid', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
-        .buildSchema();
-    const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
-    const validator = createValidator({
-        model,
-        validation: {
-            Book: {
-                description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+        ]);
+        const result2 = await validator.validateCreate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                title: 'Hello',
+                description: 'World abcdef',
             },
-        },
-    });
-    const result = await validator.validateCreate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            title: 'Hello',
-            description: 'World',
-        },
-        overRelation: null,
-        path: [],
-        mapper,
+            overRelation: null,
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result2, []);
     });
-    assert.equal(result, [
-        {
-            path: [
-                {
-                    field: 'description',
+    (0, vitest_1.it)('dependent rules invalid', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
+            .buildSchema();
+        const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
+        const validator = createValidator({
+            model,
+            validation: {
+                Book: {
+                    description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
                 },
-            ],
-            message: {
-                text: 'Minimum length is 10 characters',
             },
-        },
-    ]);
-});
-inputPreValidatorTest('dependent rules valid', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
-        .buildSchema();
-    const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
-    const validator = createValidator({
-        model,
-        validation: {
-            Book: {
-                description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+        });
+        const result = await validator.validateCreate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                title: 'Hello',
+                description: 'World',
             },
-        },
-    });
-    const result = await validator.validateCreate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            title: '',
-            description: 'World',
-        },
-        overRelation: null,
-        path: [],
-        mapper,
-    });
-    assert.equal(result, []);
-});
-inputPreValidatorTest('rules on relations', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e
-        .column('title', c => c.notNull().type(schema_1.Model.ColumnType.String))
-        .manyHasOne('author', r => r.target('Author', e => e.column('name')).notNull()))
-        .buildSchema();
-    const validator = createValidator({ model, validation: {} });
-    const result = await validator.validateCreate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            title: 'Hello',
-        },
-        overRelation: null,
-        path: [],
-        mapper,
+            overRelation: null,
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, [
+            {
+                path: [
+                    {
+                        field: 'description',
+                    },
+                ],
+                message: {
+                    text: 'Minimum length is 10 characters',
+                },
+            },
+        ]);
     });
-    assert.equal(result, [
-        {
-            path: [
-                {
-                    field: 'author',
+    (0, vitest_1.it)('dependent rules valid', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
+            .buildSchema();
+        const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
+        const validator = createValidator({
+            model,
+            validation: {
+                Book: {
+                    description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
                 },
-            ],
-            message: {
-                text: 'Field is required',
             },
-        },
-    ]);
-});
-inputPreValidatorTest('validates update', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
-        .buildSchema();
-    const validator = createValidator({
-        model,
-        validation: {
-            Book: {
-                description: [{ message: { text: 'Minimum length is 10 characters' }, validator: schema_definition_1.InputValidation.rules.minLength(10) }],
+        });
+        const result = await validator.validateCreate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                title: '',
+                description: 'World',
             },
-        },
+            overRelation: null,
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, []);
     });
-    const result = await validator.validateUpdate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            description: 'World',
-        },
-        where: {},
-        path: [],
-        mapper,
+    (0, vitest_1.it)('rules on relations', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e
+            .column('title', c => c.notNull().type(schema_1.Model.ColumnType.String))
+            .manyHasOne('author', r => r.target('Author', e => e.column('name')).notNull()))
+            .buildSchema();
+        const validator = createValidator({ model, validation: {} });
+        const result = await validator.validateCreate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                title: 'Hello',
+            },
+            overRelation: null,
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, [
+            {
+                path: [
+                    {
+                        field: 'author',
+                    },
+                ],
+                message: {
+                    text: 'Field is required',
+                },
+            },
+        ]);
     });
-    assert.equal(result, [
-        {
-            path: [
-                {
-                    field: 'description',
+    (0, vitest_1.it)('validates update', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
+            .buildSchema();
+        const validator = createValidator({
+            model,
+            validation: {
+                Book: {
+                    description: [{ message: { text: 'Minimum length is 10 characters' }, validator: schema_definition_1.InputValidation.rules.minLength(10) }],
                 },
-            ],
-            message: {
-                text: 'Minimum length is 10 characters',
             },
-        },
-    ]);
-});
-inputPreValidatorTest('validate update w dependent rules - invalid', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
-        .buildSchema();
-    const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
-    const validator = createValidator({
-        model,
-        validation: {
-            Book: {
-                description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+        });
+        const result = await validator.validateUpdate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                description: 'World',
             },
-        },
-        selects: [
+            where: {},
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, [
             {
-                entity: 'Book',
-                where: { id: (0, testUuid_1.testUuid)(1) },
-                dependencies: { title: {} },
-                result: { title: 'abcd' },
+                path: [
+                    {
+                        field: 'description',
+                    },
+                ],
+                message: {
+                    text: 'Minimum length is 10 characters',
+                },
             },
-        ],
-    });
-    const result = await validator.validateUpdate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            description: 'World',
-        },
-        where: { id: (0, testUuid_1.testUuid)(1) },
-        path: [],
-        mapper,
+        ]);
     });
-    assert.equal(result, [
-        {
-            path: [
+    (0, vitest_1.it)('validate update w dependent rules - invalid', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
+            .buildSchema();
+        const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
+        const validator = createValidator({
+            model,
+            validation: {
+                Book: {
+                    description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+                },
+            },
+            selects: [
                 {
-                    field: 'description',
+                    entity: 'Book',
+                    where: { id: (0, testUuid_1.testUuid)(1) },
+                    dependencies: { title: {} },
+                    result: { title: 'abcd' },
                 },
             ],
-            message: {
-                text: 'Minimum length is 10 characters',
+        });
+        const result = await validator.validateUpdate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                description: 'World',
             },
-        },
-    ]);
-});
-inputPreValidatorTest('validate update w dependent rules - valid', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
-        .buildSchema();
-    const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
-    const validator = createValidator({
-        model,
-        validation: {
-            Book: {
-                description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
-            },
-        },
-        selects: [
+            where: { id: (0, testUuid_1.testUuid)(1) },
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, [
             {
-                entity: 'Book',
-                where: { id: (0, testUuid_1.testUuid)(1) },
-                dependencies: { title: {} },
-                result: { title: '' },
+                path: [
+                    {
+                        field: 'description',
+                    },
+                ],
+                message: {
+                    text: 'Minimum length is 10 characters',
+                },
             },
-        ],
+        ]);
     });
-    const result = await validator.validateUpdate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            description: 'World',
-        },
-        where: { id: (0, testUuid_1.testUuid)(1) },
-        path: [],
-        mapper,
-    });
-    assert.equal(result, []);
-});
-inputPreValidatorTest('validate update with dependent rules on relation - invalid', async () => {
-    const model = new schema_definition_1.SchemaBuilder()
-        .entity('Article', e => e
-        .column('publishedAt', c => c.type(schema_1.Model.ColumnType.DateTime))
-        .manyHasOne('image', image => image.target('Image', e => e.column('url'))))
-        .buildSchema();
-    const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('publishedAt', schema_definition_1.InputValidation.rules.notNull()), schema_definition_1.InputValidation.rules.defined());
-    const validator = createValidator({
-        model,
-        validation: {
-            Article: {
-                image: [{ message: { text: 'Published article must have an image' }, validator: rule }],
+    (0, vitest_1.it)('validate update w dependent rules - valid', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Book', e => e.column('title', c => c.notNull().type(schema_1.Model.ColumnType.String)).column('description'))
+            .buildSchema();
+        const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('title', schema_definition_1.InputValidation.rules.notEmpty()), schema_definition_1.InputValidation.rules.minLength(10));
+        const validator = createValidator({
+            model,
+            validation: {
+                Book: {
+                    description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+                },
             },
-        },
-        selects: [
-            {
-                entity: 'Article',
-                where: { id: (0, testUuid_1.testUuid)(1) },
-                dependencies: { image: {} },
-                result: { id: (0, testUuid_1.testUuid)(1), image: null },
+            selects: [
+                {
+                    entity: 'Book',
+                    where: { id: (0, testUuid_1.testUuid)(1) },
+                    dependencies: { title: {} },
+                    result: { title: '' },
+                },
+            ],
+        });
+        const result = await validator.validateUpdate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                description: 'World',
             },
-        ],
-    });
-    const result = await validator.validateUpdate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Article'),
-        data: {
-            publishedAt: 'now',
-        },
-        where: { id: (0, testUuid_1.testUuid)(1) },
-        path: [],
-        mapper,
+            where: { id: (0, testUuid_1.testUuid)(1) },
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, []);
     });
-    assert.equal(result, [
-        {
-            path: [
+    (0, vitest_1.it)('validate update with dependent rules on relation - invalid', async () => {
+        const model = new schema_definition_1.SchemaBuilder()
+            .entity('Article', e => e
+            .column('publishedAt', c => c.type(schema_1.Model.ColumnType.DateTime))
+            .manyHasOne('image', image => image.target('Image', e => e.column('url'))))
+            .buildSchema();
+        const rule = schema_definition_1.InputValidation.rules.conditional(schema_definition_1.InputValidation.rules.on('publishedAt', schema_definition_1.InputValidation.rules.notNull()), schema_definition_1.InputValidation.rules.defined());
+        const validator = createValidator({
+            model,
+            validation: {
+                Article: {
+                    image: [{ message: { text: 'Published article must have an image' }, validator: rule }],
+                },
+            },
+            selects: [
                 {
-                    field: 'image',
+                    entity: 'Article',
+                    where: { id: (0, testUuid_1.testUuid)(1) },
+                    dependencies: { image: {} },
+                    result: { id: (0, testUuid_1.testUuid)(1), image: null },
                 },
             ],
-            message: {
-                text: 'Published article must have an image',
+        });
+        const result = await validator.validateUpdate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Article'),
+            data: {
+                publishedAt: 'now',
             },
-        },
-    ]);
-});
-var ViewModelDefinition;
-(function (ViewModelDefinition) {
-    class Book {
-        constructor() {
-            this.title = schema_definition_2.SchemaDefinition.stringColumn();
-            this.stats = schema_definition_2.SchemaDefinition.oneHasOneInverse(BookStats, 'book').notNull();
-        }
-    }
-    ViewModelDefinition.Book = Book;
-    let BookStats = class BookStats {
-        constructor() {
-            this.book = schema_definition_2.SchemaDefinition.oneHasOne(Book, 'stats').notNull();
-            this.foo = schema_definition_2.SchemaDefinition.intColumn();
-        }
-    };
-    BookStats = __decorate([
-        schema_definition_2.SchemaDefinition.View('SELECT 1')
-    ], BookStats);
-    ViewModelDefinition.BookStats = BookStats;
-})(ViewModelDefinition || (ViewModelDefinition = {}));
-inputPreValidatorTest('ignore not null on view relation', async () => {
-    const model = schema_definition_1.SchemaDefinition.createModel(ViewModelDefinition);
-    const validator = createValidator({ model, validation: {} });
-    const result = await validator.validateCreate({
-        entity: (0, schema_utils_1.getEntity)(model, 'Book'),
-        data: {
-            title: 'Hello',
-        },
-        overRelation: null,
-        path: [],
-        mapper,
+            where: { id: (0, testUuid_1.testUuid)(1) },
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, [
+            {
+                path: [
+                    {
+                        field: 'image',
+                    },
+                ],
+                message: {
+                    text: 'Published article must have an image',
+                },
+            },
+        ]);
+    });
+    (0, vitest_1.it)('ignore not null on view relation', async () => {
+        const model = schema_definition_1.SchemaDefinition.createModel(ViewModelDefinition);
+        const validator = createValidator({ model, validation: {} });
+        const result = await validator.validateCreate({
+            entity: (0, schema_utils_1.getEntity)(model, 'Book'),
+            data: {
+                title: 'Hello',
+            },
+            overRelation: null,
+            path: [],
+            mapper,
+        });
+        vitest_1.assert.deepStrictEqual(result, []);
     });
-    assert.equal(result, []);
 });
-inputPreValidatorTest.run();
 //# sourceMappingURL=inputPreValidator.test.js.map