@sprucelabs/schema 25.5.65 → 25.5.69

package/build/esm/__tests__/behavioral/GeneratesVersionedRelationshipTemplates.test.js

@@ -1,191 +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 SchemaField from '../../fields/SchemaField.js';
-import { TemplateRenderAs, } from '../../types/template.types.js';
-import buildSchema from '../../utilities/buildSchema.js';
-export default class GeneratesRelationshipTemplatesTest extends AbstractSpruceTest {
-    static testTemplateDetails(definition, renderAsValue, renderAsType, renderAsSchemaType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const templateOptions = {
-                language: 'ts',
-                globalNamespace: 'SpruceSchemas',
-                importAs: 'generated_test',
-                templateItems: GeneratesRelationshipTemplatesTest.templateItems,
-                definition: Object.assign(Object.assign({}, definition), { type: 'schema' }),
-                renderAs: TemplateRenderAs.Type, // is overwritten below
-            };
-            const expected = {
-                renderAsValue,
-                renderAsType,
-                renderAsSchemaType,
-            };
-            const rendersAs = Object.getOwnPropertyNames(TemplateRenderAs);
-            rendersAs.forEach((renderAs) => {
-                const options = Object.assign(Object.assign({}, templateOptions), { 
-                    // @ts-ignore
-                    renderAs: TemplateRenderAs[renderAs] });
-                const { valueType } = SchemaField.generateTemplateDetails(options);
-                const exp = expected[`renderAs${renderAs}`];
-                assert.isEqual(valueType, exp);
-            });
-        });
-    }
-    static throwsMissingVersion(definition) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const templateOptions = {
-                language: 'ts',
-                globalNamespace: 'SpruceSchemas',
-                importAs: 'generated_test',
-                templateItems: GeneratesRelationshipTemplatesTest.templateItems,
-                definition: Object.assign(Object.assign({}, definition), { type: 'schema' }),
-                renderAs: TemplateRenderAs.Type, // is overwritten below
-            };
-            const rendersAs = Object.getOwnPropertyNames(TemplateRenderAs);
-            yield Promise.all(rendersAs.map((renderAs) => __awaiter(this, void 0, void 0, function* () {
-                const options = Object.assign(Object.assign({}, templateOptions), { 
-                    // @ts-ignore
-                    renderAs: TemplateRenderAs[renderAs] });
-                assert.doesThrow(() => SchemaField.generateTemplateDetails(options), /VERSION/);
-            })));
-        });
-    }
-}
-GeneratesRelationshipTemplatesTest.wrenchV1Schema = buildSchema({
-    id: 'wrench',
-    name: 'Wrench',
-    version: 'v1',
-    fields: {
-        wrenchSize: {
-            type: 'number',
-            label: 'Size',
-        },
-    },
-});
-GeneratesRelationshipTemplatesTest.wrenchV2Schema = buildSchema({
-    id: 'wrench',
-    name: 'Wrench',
-    version: 'v2',
-    fields: {
-        wrenchSize: {
-            type: 'number',
-            label: 'Size',
-        },
-    },
-});
-GeneratesRelationshipTemplatesTest.screwdriverSchema = buildSchema({
-    id: 'screwdriver',
-    name: 'Screwdriver',
-    fields: {
-        isFlathead: {
-            type: 'boolean',
-        },
-        screwdriverLength: {
-            type: 'number',
-            label: 'Length',
-        },
-    },
-});
-GeneratesRelationshipTemplatesTest.personSchema = buildSchema({
-    id: 'union-person',
-    name: 'Union Person',
-    fields: {
-        favoriteTool: {
-            type: 'schema',
-            options: {
-                schemas: [
-                    GeneratesRelationshipTemplatesTest.wrenchV1Schema,
-                    GeneratesRelationshipTemplatesTest.wrenchV2Schema,
-                    GeneratesRelationshipTemplatesTest.screwdriverSchema,
-                ],
-            },
-        },
-        tools: {
-            type: 'schema',
-            isArray: true,
-            options: {
-                schemas: [
-                    GeneratesRelationshipTemplatesTest.wrenchV1Schema,
-                    GeneratesRelationshipTemplatesTest.wrenchV2Schema,
-                    GeneratesRelationshipTemplatesTest.screwdriverSchema,
-                ],
-            },
-        },
-    },
-});
-// the global template items[]
-GeneratesRelationshipTemplatesTest.templateItems = [
-    {
-        namePascal: 'UnionPerson',
-        nameCamel: 'unionPerson',
-        nameReadable: 'Union person',
-        namespace: 'Core',
-        id: GeneratesRelationshipTemplatesTest.personSchema.id,
-        schema: GeneratesRelationshipTemplatesTest.personSchema,
-        destinationDir: '#spruce/schemas',
-    },
-    {
-        namePascal: 'Wrench',
-        nameCamel: 'wrench',
-        nameReadable: 'Wrench',
-        namespace: 'Core',
-        id: GeneratesRelationshipTemplatesTest.wrenchV1Schema.id,
-        schema: GeneratesRelationshipTemplatesTest.wrenchV1Schema,
-        destinationDir: '#spruce/schemas',
-    },
-    {
-        namePascal: 'Wrench',
-        nameCamel: 'wrench',
-        nameReadable: 'Wrench',
-        namespace: 'Core',
-        id: GeneratesRelationshipTemplatesTest.wrenchV2Schema.id,
-        schema: GeneratesRelationshipTemplatesTest.wrenchV2Schema,
-        destinationDir: '#spruce/schemas',
-    },
-    {
-        namePascal: 'screwdriver',
-        nameCamel: 'screwdriver',
-        nameReadable: 'Screwdriver',
-        namespace: 'Core',
-        id: GeneratesRelationshipTemplatesTest.screwdriverSchema.id,
-        schema: GeneratesRelationshipTemplatesTest.screwdriverSchema,
-        destinationDir: '#spruce/schemas',
-    },
-];
-__decorate([
-    test('single value', {
-        isArray: false,
-        options: {
-            schemaIds: [{ id: 'union-person' }, { id: 'wrench', version: 'v2' }],
-        },
-    }, '[unionPersonSchema, wrenchSchema_v2]', "{ schemaId: 'union-person', values: SpruceSchemas.Core.UnionPerson } | { schemaId: 'wrench', version: 'v2', values: SpruceSchemas.Core.v2.Wrench }", '(SpruceSchemas.Core.UnionPersonSchema | SpruceSchemas.Core.v2.WrenchSchema)[]'),
-    test('is array', {
-        isArray: true,
-        options: {
-            schemaIds: [{ id: 'union-person' }, { id: 'wrench', version: 'v1' }],
-        },
-    }, '[unionPersonSchema, wrenchSchema_v1]', "({ schemaId: 'union-person', values: SpruceSchemas.Core.UnionPerson } | { schemaId: 'wrench', version: 'v1', values: SpruceSchemas.Core.v1.Wrench })[]", '(SpruceSchemas.Core.UnionPersonSchema | SpruceSchemas.Core.v1.WrenchSchema)[]')
-], GeneratesRelationshipTemplatesTest, "testTemplateDetails", null);
-__decorate([
-    test('missing version non array value', {
-        isArray: false,
-        options: { schemaIds: [{ id: 'union-person' }, { id: 'wrench' }] },
-    }),
-    test('missing version array value', {
-        isArray: true,
-        options: { schemaId: { id: 'wrench' } },
-    })
-], GeneratesRelationshipTemplatesTest, "throwsMissingVersion", null);

package/build/esm/__tests__/behavioral/GettingFieldsOffASchema.test.d.ts

@@ -1,7 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class GettingFieldsOffASchemaTest extends AbstractSchemaTest {
-    protected static throwsWithNothingPassed(): Promise<void>;
-    protected static noFieldsThrows(): Promise<void>;
-    protected static getsBacksFields(): Promise<void>;
-    protected static getsBackMoreFields(): Promise<void>;
-}

package/build/esm/__tests__/behavioral/GettingFieldsOffASchema.test.js

@@ -1,88 +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 { errorAssertUtil } from '@sprucelabs/test-utils';
-import { buildSchema } from '../../index.js';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import getFields from '../../utilities/getFields.js';
-const noFieldsSchema = buildSchema({
-    id: 'noField',
-    fields: {},
-});
-const withFieldsSchema = buildSchema({
-    id: 'withField',
-    fields: {
-        firstName: {
-            type: 'text',
-        },
-    },
-});
-const withManyFieldsSchema = buildSchema({
-    id: 'withManyField',
-    fields: {
-        firstName: {
-            type: 'text',
-        },
-        lastName: {
-            type: 'text',
-        },
-    },
-});
-export default class GettingFieldsOffASchemaTest extends AbstractSchemaTest {
-    static throwsWithNothingPassed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            //@ts-ignore
-            const err = assert.doesThrow(() => getFields());
-            errorAssertUtil.assertError(err, 'INVALID_PARAMETERS', {
-                parameters: ['schema'],
-            });
-        });
-    }
-    static noFieldsThrows() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => getFields(noFieldsSchema));
-            errorAssertUtil.assertError(err, 'INVALID_PARAMETERS', {
-                parameters: ['schema'],
-            });
-        });
-    }
-    static getsBacksFields() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const actual = getFields(withFieldsSchema);
-            assert.isEqualDeep(actual, ['firstName']);
-            assert.isExactType(true);
-        });
-    }
-    static getsBackMoreFields() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const actual = getFields(withManyFieldsSchema);
-            assert.isEqualDeep(actual, ['firstName', 'lastName']);
-            assert.isExactType(true);
-        });
-    }
-}
-__decorate([
-    test()
-], GettingFieldsOffASchemaTest, "throwsWithNothingPassed", null);
-__decorate([
-    test()
-], GettingFieldsOffASchemaTest, "noFieldsThrows", null);
-__decorate([
-    test()
-], GettingFieldsOffASchemaTest, "getsBacksFields", null);
-__decorate([
-    test()
-], GettingFieldsOffASchemaTest, "getsBackMoreFields", null);

package/build/esm/__tests__/behavioral/HandlesDynamicFields.test.d.ts

@@ -1,17 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-import { Schema } from '../../schemas.static.types';
-export default class HandlesDynamicFields extends AbstractSchemaTest {
-    protected static canCreateSchemaEntityWithDynamicFields(): void;
-    protected static optionalValuesTypeMapping(): void;
-    protected static requiredValuesTypeMapping(): void;
-    protected static typesStringValuesProperly(): void;
-    protected static typesNumbersValuesProperly(): void;
-    protected static typesRequiredNumbersValuesProperly(): void;
-    protected static getValuesTransformation(schema: Schema, values: any, expected: any): void;
-    protected static canValidate(): void;
-    protected static canValidateUsingUtilityFunction(): void;
-    protected static getsSets(): void;
-    protected static throwsOnBadSet(): void;
-    protected static typesAndNormalizedRelatedSchemasWithDynamicFields(): void;
-    protected static typesAndNormalizesDynamicSchemas(): void;
-}

package/build/esm/__tests__/behavioral/HandlesDynamicFields.test.js

@@ -1,284 +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;
-};
-import { assert, test } from '@sprucelabs/test';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import DynamicSchemaEntityImplementation from '../../DynamicSchemaEntityImplementation.js';
-import areSchemaValuesValid from '../../utilities/areSchemaValuesValid.js';
-import buildSchema from '../../utilities/buildSchema.js';
-import normalizeSchemaValues from '../../utilities/normalizeSchemaValues.js';
-import validateSchemaValues from '../../utilities/validateSchemaValues.js';
-const textDynamicSchema = buildSchema({
-    id: 'textDynamic',
-    name: 'Dynamic text based schema',
-    dynamicFieldSignature: {
-        type: 'text',
-        keyName: 'key',
-    },
-});
-const numberDynamicSchema = buildSchema({
-    id: 'numberDynamic',
-    name: 'Dynamic number based schema',
-    dynamicFieldSignature: {
-        type: 'number',
-        keyName: 'key',
-    },
-});
-const numberRequiredDynamicSchema = buildSchema({
-    id: 'numberRequiredDynamic',
-    name: 'Dynamic number based schema',
-    dynamicFieldSignature: {
-        type: 'number',
-        isRequired: true,
-        keyName: 'key',
-    },
-});
-const arrayRequiredDynamicSchema = buildSchema({
-    id: 'arrayRequiredDynamic',
-    name: 'Dynamic number based schema',
-    dynamicFieldSignature: {
-        type: 'number',
-        isRequired: true,
-        isArray: true,
-        keyName: 'key',
-    },
-});
-export default class HandlesDynamicFields extends AbstractSchemaTest {
-    static canCreateSchemaEntityWithDynamicFields() {
-        const entity = new DynamicSchemaEntityImplementation(textDynamicSchema);
-        assert.isTruthy(entity);
-    }
-    static optionalValuesTypeMapping() {
-        const values = {
-            hey: 5,
-        };
-        assert.isExactType(true);
-    }
-    static requiredValuesTypeMapping() {
-        const values = {
-            hey: 5,
-        };
-        assert.isExactType(true);
-        assert.isExactType(false);
-    }
-    static typesStringValuesProperly() {
-        const entity = new DynamicSchemaEntityImplementation(textDynamicSchema, {
-            anything: 'foo',
-            anythingElse: 'bar',
-        });
-        const values = entity.getValues();
-        assert.isExactType(true);
-    }
-    static typesNumbersValuesProperly() {
-        const entity = new DynamicSchemaEntityImplementation(numberDynamicSchema, {
-            anything: 1,
-            anythingElse: 3,
-        });
-        const values = entity.getValues();
-        assert.isExactType(true);
-    }
-    static typesRequiredNumbersValuesProperly() {
-        const entity = new DynamicSchemaEntityImplementation(numberRequiredDynamicSchema, {
-            anything: 1,
-            anythingElse: 3,
-        });
-        const values = entity.getValues();
-        assert.isExactType(true);
-        assert.isExactType(false);
-    }
-    static getValuesTransformation(schema, values, expected) {
-        const entity = new DynamicSchemaEntityImplementation(schema, values);
-        const actual = entity.getValues();
-        assert.isEqualDeep(actual, expected);
-        const entity2 = new DynamicSchemaEntityImplementation(schema);
-        entity2.setValues(values);
-        const actual2 = entity.getValues();
-        assert.isEqualDeep(actual2, expected);
-    }
-    static canValidate() {
-        const entity = new DynamicSchemaEntityImplementation(textDynamicSchema, {
-            //@ts-ignore
-            foo: { another: 'object' },
-        });
-        assert.doesThrow(() => entity.validate(), /should be a string/);
-        assert.isFalse(entity.isValid());
-    }
-    static canValidateUsingUtilityFunction() {
-        const values = {
-            foo: { another: 'object' },
-        };
-        assert.doesThrow(() => 
-        //@ts-ignore
-        validateSchemaValues(textDynamicSchema, values, {
-            shouldMapToParameterErrors: false,
-        }), /should be a string/);
-        //@ts-ignore
-        assert.isFalse(areSchemaValuesValid(textDynamicSchema, values));
-    }
-    static getsSets() {
-        const entity = new DynamicSchemaEntityImplementation(textDynamicSchema);
-        entity.set('foo', 'bar');
-        assert.isEqual(entity.get('foo'), 'bar');
-        //@ts-ignore
-        entity.set('bar', 3);
-        assert.isEqual(entity.get('bar'), '3');
-    }
-    static throwsOnBadSet() {
-        const entity = new DynamicSchemaEntityImplementation(numberDynamicSchema);
-        assert.doesThrow(
-        //@ts-ignore
-        () => entity.set('foo', { hello: 'world' }), /not a number/);
-    }
-    static typesAndNormalizedRelatedSchemasWithDynamicFields() {
-        const fullSchema = buildSchema({
-            id: 'fullMessageAdapter',
-            fields: {
-                id: {
-                    type: 'id',
-                    isRequired: true,
-                },
-                dateCreated: {
-                    type: 'number',
-                    isRequired: true,
-                },
-                adapterName: {
-                    type: 'text',
-                    isRequired: true,
-                },
-                settings: {
-                    type: 'schema',
-                    isRequired: true,
-                    options: {
-                        schema: buildSchema({
-                            id: 'messageAdapterSettings',
-                            dynamicFieldSignature: {
-                                type: 'text',
-                                keyName: 'key',
-                            },
-                        }),
-                    },
-                },
-            },
-        });
-        const values = {
-            id: '1',
-            dateCreated: 2,
-            adapterName: '3',
-            settings: {},
-        };
-        values.settings.anything = 'true';
-        assert.isExactType(true);
-        const allValues = {
-            id: '1',
-            dateCreated: 2,
-            adapterName: '3',
-            settings: {
-                first: 'first',
-            },
-        };
-        assert.isExactType(true);
-        const normalized = normalizeSchemaValues(fullSchema, {
-            //@ts-ignore
-            id: 1,
-            //@ts-ignore
-            dateCreated: '2',
-            //@ts-ignore
-            adapterName: 4,
-            settings: {
-                first: 'first',
-                //@ts-ignore
-                second: 2,
-            },
-        }, { shouldIncludePrivateFields: false });
-        assert.isEqualDeep(normalized, {
-            id: '1',
-            dateCreated: 2,
-            adapterName: '4',
-            settings: {
-                first: 'first',
-                second: '2',
-            },
-        });
-    }
-    static typesAndNormalizesDynamicSchemas() {
-        const fullSchema = buildSchema({
-            id: 'aDynamicSchema',
-            dynamicFieldSignature: {
-                type: 'text',
-                keyName: 'key',
-            },
-        });
-        const values = {
-            id: '1',
-            dateCreated: 'hey',
-            adapterName: '3',
-            settings: 'there',
-        };
-        values.anything = 'true';
-        assert.isExactType(true);
-        const normalized = normalizeSchemaValues(fullSchema, {
-            //@ts-ignore
-            id: 1,
-            //@ts-ignore
-            dateCreated: '2',
-            //@ts-ignore
-            adapterName: 4,
-        });
-        assert.isEqualDeep(normalized, {
-            id: '1',
-            dateCreated: '2',
-            adapterName: '4',
-        });
-    }
-}
-__decorate([
-    test()
-], HandlesDynamicFields, "canCreateSchemaEntityWithDynamicFields", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "optionalValuesTypeMapping", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "requiredValuesTypeMapping", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "typesStringValuesProperly", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "typesNumbersValuesProperly", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "typesRequiredNumbersValuesProperly", null);
-__decorate([
-    test('simple string passthrough', textDynamicSchema, { foo: 'bar', hello: 'world' }, { foo: 'bar', hello: 'world' }),
-    test('simple number passthrough', numberDynamicSchema, { foo: 1, hello: 2 }, { foo: 1, hello: 2 }),
-    test('transforms to strings', textDynamicSchema, { foo: 1, hello: 2 }, { foo: '1', hello: '2' }),
-    test('transforms to numbers+array', arrayRequiredDynamicSchema, {
-        foo: 1,
-        bar: 2,
-    }, {
-        foo: [1],
-        bar: [2],
-    })
-], HandlesDynamicFields, "getValuesTransformation", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "canValidate", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "canValidateUsingUtilityFunction", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "getsSets", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "throwsOnBadSet", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "typesAndNormalizedRelatedSchemasWithDynamicFields", null);
-__decorate([
-    test()
-], HandlesDynamicFields, "typesAndNormalizesDynamicSchemas", null);

package/build/esm/__tests__/behavioral/HandlesHidingPrivateFields.test.d.ts

@@ -1,11 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class HandlesHidingPrivateFieldsTest extends AbstractSchemaTest {
-    protected static typeMappingFieldNamesWorks(): void;
-    protected static typeMappingValuesWorks(): void;
-    protected static schemaCanDropPrivateFields(): Promise<void>;
-    protected static schemaCanKeepPrivateFields(): Promise<void>;
-    protected static schemaCanDropPrivateFieldsWhenSelectingFields(): Promise<void>;
-    protected static normalizeCanDropPrivateFields(): void;
-    protected static normalizeCanKeepPrivateFields(): void;
-    protected static dropsPrivateFieldsWhileSelectingFields(): void;
-}