@sprucelabs/schema 25.5.64 → 25.5.68

package/build/esm/__tests__/implementation/SelectField.test.js

@@ -1,127 +0,0 @@
-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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import AbstractSpruceTest, { test, assert } from '@sprucelabs/test';
-import { FieldFactory } from '../../index.js';
-import StaticSchemaEntityImplementation from '../../StaticSchemaEntityImplementation.js';
-import buildSchema from '../../utilities/buildSchema.js';
-export default class SelectFieldTest extends AbstractSpruceTest {
-    static canMakeSelectOptionsUnion() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = new StaticSchemaEntityImplementation(this.userSchema, {
-                favoriteColor: 'blue',
-                favoriteColorRequired: 'blue',
-            });
-            const favColor = user.get('favoriteColor');
-            const favoriteColorRequired = user.get('favoriteColorRequired');
-            assert.isType(favColor);
-            assert.isType(favoriteColorRequired);
-        });
-    }
-    static catchesBadChoice() {
-        const field = FieldFactory.Field('test', {
-            type: 'select',
-            options: {
-                choices: [
-                    { label: 'good', value: 'good' },
-                    { label: 'bad', value: 'bad' },
-                    { label: 'ugly', value: 'ugly' },
-                ],
-            },
-        });
-        const results = field.validate('cheese');
-        assert.isLength(results, 1);
-        assert.isEqual(results[0].code, 'INVALID_PARAMETER');
-    }
-    static validationHandlesUndefinedForOptional() {
-        const field = FieldFactory.Field('test', {
-            type: 'select',
-            options: {
-                choices: [
-                    { label: 'good', value: 'good' },
-                    { label: 'bad', value: 'bad' },
-                    { label: 'ugly', value: 'ugly' },
-                ],
-            },
-        });
-        const results = field.validate(undefined);
-        assert.isLength(results, 0);
-    }
-    static validationHandlesRequired() {
-        const field = FieldFactory.Field('test', {
-            type: 'select',
-            isRequired: true,
-            options: {
-                choices: [
-                    { label: 'good', value: 'good' },
-                    { label: 'bad', value: 'bad' },
-                    { label: 'ugly', value: 'ugly' },
-                ],
-            },
-        });
-        const results = field.validate(undefined);
-        assert.isLength(results, 1);
-        assert.isEqual(results[0].code, 'MISSING_PARAMETER');
-    }
-}
-SelectFieldTest.userSchema = buildSchema({
-    id: 'select-union-test',
-    name: 'select union test',
-    fields: {
-        favoriteColor: {
-            type: 'select',
-            options: {
-                choices: [
-                    {
-                        value: 'blue',
-                        label: 'Blue',
-                    },
-                    {
-                        value: 'red',
-                        label: 'Red',
-                    },
-                ],
-            },
-        },
-        favoriteColorRequired: {
-            type: 'select',
-            isRequired: true,
-            options: {
-                choices: [
-                    {
-                        value: 'blue',
-                        label: 'Blue',
-                    },
-                    {
-                        value: 'red',
-                        label: 'Red',
-                    },
-                ],
-            },
-        },
-    },
-});
-__decorate([
-    test('Makes select options a union (test passes, lint will fail)')
-], SelectFieldTest, "canMakeSelectOptionsUnion", null);
-__decorate([
-    test()
-], SelectFieldTest, "catchesBadChoice", null);
-__decorate([
-    test()
-], SelectFieldTest, "validationHandlesUndefinedForOptional", null);
-__decorate([
-    test()
-], SelectFieldTest, "validationHandlesRequired", null);

package/build/esm/__tests__/implementation/TextField.test.d.ts

@@ -1,4 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class TextFieldTest extends AbstractSchemaTest {
-    protected static zeroLengthStringFailsValidationWhenRequired(): Promise<void>;
-}

package/build/esm/__tests__/implementation/TextField.test.js

@@ -1,34 +0,0 @@
-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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { test, assert } from '@sprucelabs/test';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import FieldFactory from '../../factories/FieldFactory.js';
-export default class TextFieldTest extends AbstractSchemaTest {
-    static zeroLengthStringFailsValidationWhenRequired() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const field = FieldFactory.Field('firstName', {
-                type: 'text',
-                isRequired: true,
-            });
-            const errors = field.validate('');
-            assert.isAbove(errors.length, 0);
-            assert.isEqual(errors[0].code, 'MISSING_PARAMETER');
-        });
-    }
-}
-__decorate([
-    test()
-], TextFieldTest, "zeroLengthStringFailsValidationWhenRequired", null);

package/build/esm/__tests__/implementation/ValidateErrorMessageFormatter.test.d.ts

@@ -1,16 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-import { RenderOptions } from '../../errors/ValidateErrorMessageFormatter';
-export default class ValidateErrorMessageFormatterTest extends AbstractSpruceTest {
-    protected static throwsWhenMissingValidateError(): Promise<void>;
-    protected static throwsWhenSentBadErrorCode(): Promise<void>;
-    protected static throwsWhenSentBadError(): Promise<void>;
-    protected static outputsSchemaIdOrName(options?: RenderOptions): Promise<void>;
-    protected static showAccurateCountOfErrors(): Promise<void>;
-    protected static canCountNestedErrors(): Promise<void>;
-    protected static outputsAllTheFieldsAThatAreWrong(): Promise<void>;
-    protected static outputsAllTheFieldsAThatAreWrongIncludingNested(): Promise<void>;
-    protected static rendersFriendlyMessageIfItExists(): void;
-    private static renderError;
-    private static ValidationError;
-    private static Formatter;
-}

package/build/esm/__tests__/implementation/ValidateErrorMessageFormatter.test.js

@@ -1,216 +0,0 @@
-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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import AbstractSpruceTest, { test, assert } from '@sprucelabs/test';
-import { errorAssertUtil } from '@sprucelabs/test-utils';
-import SpruceError from '../../errors/SpruceError.js';
-import { ValidateErrorMessageFormatter, } from '../../errors/ValidateErrorMessageFormatter.js';
-export default class ValidateErrorMessageFormatterTest extends AbstractSpruceTest {
-    static throwsWhenMissingValidateError() {
-        return __awaiter(this, void 0, void 0, function* () {
-            //@ts-ignore
-            const err = assert.doesThrow(() => this.Formatter());
-            errorAssertUtil.assertError(err, 'MISSING_PARAMETERS', {
-                parameters: ['error'],
-            });
-        });
-    }
-    static throwsWhenSentBadErrorCode() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => this.Formatter(
-            //@ts-ignore
-            new SpruceError({ code: 'MISSING_PARAMETERS', parameters: [] })));
-            errorAssertUtil.assertError(err, 'INVALID_PARAMETERS', {
-                parameters: ['error'],
-            });
-        });
-    }
-    static throwsWhenSentBadError() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(
-            //@ts-ignore
-            () => this.Formatter(new Error('yay')));
-            errorAssertUtil.assertError(err, 'INVALID_PARAMETERS', {
-                parameters: ['error'],
-            });
-        });
-    }
-    static outputsSchemaIdOrName(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schemaId = `${new Date().getTime()}`;
-            const schemaName = `${new Date().getTime() * 2}`;
-            const message = this.renderError({ schemaId, schemaName }, options);
-            if (options === null || options === void 0 ? void 0 : options.shouldUseReadableNames) {
-                assert.doesInclude(message, schemaName);
-            }
-            else {
-                assert.doesInclude(message, schemaId);
-            }
-        });
-    }
-    static showAccurateCountOfErrors() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.doesInclude(this.renderError({ errors: [] }), '0 errors');
-            assert.doesInclude(this.renderError({
-                errors: [
-                    {
-                        code: 'INVALID_PARAMETER',
-                        name: 'firstName',
-                    },
-                ],
-            }), '1 error!');
-            assert.doesInclude(this.renderError({
-                errors: [
-                    {
-                        code: 'INVALID_PARAMETER',
-                        name: 'firstName',
-                    },
-                    {
-                        code: 'INVALID_PARAMETER',
-                        name: 'lastName',
-                    },
-                ],
-            }), '2 errors!');
-        });
-    }
-    static canCountNestedErrors() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.doesInclude(this.renderError({
-                errors: [
-                    {
-                        code: 'INVALID_PARAMETER',
-                        name: 'favoriteColor',
-                        errors: [
-                            {
-                                code: 'MISSING_PARAMETER',
-                                name: 'name',
-                            },
-                            {
-                                code: 'MISSING_PARAMETER',
-                                name: 'rgb',
-                            },
-                        ],
-                    },
-                ],
-            }), '2 errors');
-        });
-    }
-    static outputsAllTheFieldsAThatAreWrong() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const name1 = `${new Date().getTime()}`;
-            const name2 = `${new Date().getTime() * 2}`;
-            const msg = this.renderError({
-                errors: [
-                    {
-                        code: 'INVALID_PARAMETER',
-                        name: name1,
-                    },
-                    {
-                        code: 'MISSING_PARAMETER',
-                        name: name2,
-                    },
-                    {
-                        code: 'MISSING_PARAMETER',
-                        name: 'rgb',
-                    },
-                ],
-            });
-            assert.doesInclude(msg, new RegExp(`${name1}.*is.*invalid`, `gis`));
-            assert.doesInclude(msg, new RegExp(`${name2}.*is.*required`, `gis`));
-            assert.doesInclude(msg, new RegExp(`rgb.*is.*required`, `gis`));
-        });
-    }
-    static outputsAllTheFieldsAThatAreWrongIncludingNested() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const name1 = `${new Date().getTime()}`;
-            const name2 = `${new Date().getTime() * 2}`;
-            const msg = this.renderError({
-                errors: [
-                    {
-                        code: 'INVALID_PARAMETER',
-                        name: name1,
-                        errors: [
-                            {
-                                code: 'MISSING_PARAMETER',
-                                name: name2,
-                            },
-                            {
-                                code: 'MISSING_PARAMETER',
-                                name: 'rgb',
-                            },
-                        ],
-                    },
-                ],
-            });
-            assert.doesNotInclude(msg, new RegExp(`${name1}.*is.*invalid`, `gis`));
-            assert.doesInclude(msg, new RegExp(`${name1}.${name2}.*is.*required`, `gis`));
-            assert.doesNotInclude(msg, new RegExp(`${name1}.*has 2 errors`, `gis`));
-        });
-    }
-    static rendersFriendlyMessageIfItExists() {
-        const msg = this.renderError({
-            errors: [
-                {
-                    code: 'INVALID_PARAMETER',
-                    name: 'firstName',
-                    friendlyMessage: 'This is crazy!',
-                },
-            ],
-        });
-        assert.doesInclude(msg, '1. (firstName) This is crazy!');
-    }
-    static renderError(errorOptions, renderOptions) {
-        const error = this.ValidationError(errorOptions);
-        const formatter = this.Formatter(error);
-        const message = formatter.render(renderOptions);
-        return message;
-    }
-    static ValidationError(options) {
-        return new SpruceError(Object.assign({ code: 'VALIDATION_FAILED', schemaId: `${Math.random()}`, schemaName: `${Math.random() * 2} name`, errors: [] }, options));
-    }
-    static Formatter(error) {
-        return new ValidateErrorMessageFormatter(error);
-    }
-}
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "throwsWhenMissingValidateError", null);
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "throwsWhenSentBadErrorCode", null);
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "throwsWhenSentBadError", null);
-__decorate([
-    test('renders schemaId by default'),
-    test('renders schemaName with shouldUseReadableNames', {
-        shouldUseReadableNames: true,
-    })
-], ValidateErrorMessageFormatterTest, "outputsSchemaIdOrName", null);
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "showAccurateCountOfErrors", null);
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "canCountNestedErrors", null);
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "outputsAllTheFieldsAThatAreWrong", null);
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "outputsAllTheFieldsAThatAreWrongIncludingNested", null);
-__decorate([
-    test()
-], ValidateErrorMessageFormatterTest, "rendersFriendlyMessageIfItExists", null);