@raytio/core 11.4.1 → 11.6.0

package/dist/schema/expandSchema/__tests__/expandSchema.test.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const expandSchema_1 = require("../expandSchema");
-const fromAPI = [
-    {
-        schema_name: "ps_Vessel",
-        start_date: "1970-01-01T00:00:00+00:00",
-        end_date: "2222-12-31T23:59:59+00:00",
-        active: true,
-        version_current: true,
-        schema_version: "0.0.7",
-        schema_type: "ps",
-        schema: {
-            $id: "https://api.rayt.io/graph/v1/schema/ps/ps_Vessel",
-            $schema: "http://json-schema.org/draft-07/schema#",
-            title: "Vessel/Boat",
-            description: "A schema that describes a maritime vessel",
-            i18n: {
-                "mi-NZ": {
-                    $schema: { title: "Waka" },
-                    vesselName: { title: "nga waka ingoa" },
-                },
-            },
-            tags: ["time:action1:20"],
-            required: ["vesselName"],
-            properties: {
-                manufacture_year: {
-                    allOf: [
-                        { $ref: "#/definitions/ss_birth_year_integer" },
-                        { tags: ["aaa"], priority: 700 },
-                    ],
-                },
-                vesselName: { type: "string", title: "Vessel Name", priority: 1000 },
-            },
-            definitions: {
-                ss_birth_year_integer: { $ref: "urn:schema:ss_birth_year_integer" },
-            },
-        },
-    },
-    {
-        schema_name: "ss_birth_year_integer",
-        schema_version: "0.0.1",
-        schema: {
-            $id: "this field often has typos. in this case its blatantly wrong",
-            $schema: "https://whatever",
-            maximum: 2022,
-            minimum: 1900,
-            tags: ["type:globally_unique_field"],
-            title: "Year of birth",
-        },
-    },
-];
-describe("expandSchema", () => {
-    it("can do the entire expansion process", () => {
-        expect((0, expandSchema_1.expandSchema)(fromAPI[0], fromAPI, ["lb-LU"])).toStrictEqual({
-            wasExpandedByClient: true,
-            // $schema was removed
-            name: "ps_Vessel",
-            title: "Vessel/Boat",
-            description: "A schema that describes a maritime vessel",
-            start_date: "1970-01-01T00:00:00+00:00",
-            end_date: "2222-12-31T23:59:59+00:00",
-            version: "0.0.7",
-            schema_type: "ps",
-            i18n: fromAPI[0].schema.i18n, // unchanged
-            isProfileSchema: true,
-            isSpSchema: false,
-            properties: {
-                manufacture_year: {
-                    // $id was removed
-                    $prop: "manufacture_year",
-                    $ref: "ss_birth_year_integer", // it added a $ref tag
-                    maximum: 2022,
-                    minimum: 1900,
-                    title: "Year of birth",
-                    // it merged the allOf into a single object
-                    priority: 700,
-                    tags: ["aaa", "type:globally_unique_field"],
-                },
-                vesselName: {
-                    $prop: "vesselName",
-                    // no $ref attribute
-                    priority: 1000,
-                    title: "Vessel Name",
-                    type: "string",
-                },
-            },
-            required: ["vesselName"],
-            tags: ["time:action1:20"],
-            timing: {
-                action1: 20,
-            },
-            verified_fields: undefined,
-        });
-    });
-});

package/dist/schema/expandSchema/__tests__/i18n.test.d.ts

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

package/dist/schema/expandSchema/__tests__/i18n.test.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const i18n_1 = require("../i18n");
-const DEFAULT_LOCALES = ["de-DE"]; // match what the client does in vi.setup.ts
-describe("getAllLocales", () => {
-    it("correctly expands languages with a country-componentand lowercases them", () => {
-        const expanded = (0, i18n_1.getAllLocales)([
-            "en-NZ",
-            "de-CH",
-            "be",
-            "ar-001",
-            "az-Cyrl-AZ",
-        ]);
-        expect(expanded).toStrictEqual([
-            "en-nz",
-            "en",
-            "de-ch",
-            "de",
-            "be",
-            "ar-001",
-            "ar",
-            "az-cyrl-az",
-            "az",
-        ]);
-    });
-});
-describe("findSuitableLocale", () => {
-    it("picks the most appropriate option", () => {
-        // the users's locale is `de-DE`, so it picked the most appropriate one from the options: `de-AT`
-        expect((0, i18n_1.findSuitableLocale)(["en-029", "de-AT", "fr-FR"], DEFAULT_LOCALES)).toBe("de-AT");
-    });
-});

package/dist/schema/expandSchema/__tests__/maybeUseI18n.test.d.ts

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

package/dist/schema/expandSchema/__tests__/maybeUseI18n.test.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const maybeUseI18n_1 = require("../maybeUseI18n");
-const DEFAULT_LOCALES = ["de-DE"]; // match what the client does in vi.setup.ts
-describe("maybeUseI18n", () => {
-    it("correctly applies schema-wise overrides", () => {
-        const originalSchema = {
-            schema_group: "old_schemas",
-            title: "Default title",
-            description: "default desc",
-            i18n: {
-                "de-de": {
-                    $schema: {
-                        title: "der Name dieses Schema",
-                        description: "eine Beschreibung in Deutsch",
-                    },
-                    old_schemas: {
-                        title_plural: "All the old sChema",
-                    },
-                },
-            },
-        };
-        const translatedSchema = (0, maybeUseI18n_1.maybeUseI18n)(originalSchema, DEFAULT_LOCALES);
-        expect(translatedSchema).toStrictEqual({
-            schema_group: "old_schemas",
-            group_title: "All the old sChema",
-            title: "der Name dieses Schema",
-            description: "eine Beschreibung in Deutsch",
-            clientLocale: "de-de",
-            groupNames: {},
-            properties: {},
-            i18n: originalSchema.i18n,
-        });
-    });
-    it("corretly creates a groupNames property with the correct locale", () => {
-        const originalSchema = {
-            i18n: {
-                "en-nz": {
-                    "group:DoB": { title: "Your date of birth" },
-                },
-                "fr-fr": {
-                    "group:DoB": { title: "anniversaire" },
-                },
-                "de-de": {
-                    "group:DoB": { title: "dein Geburtstag" },
-                },
-            },
-            properties: {
-                year_of_birth: {
-                    tags: ["group:DoB"],
-                },
-            },
-        };
-        const translatedSchema = (0, maybeUseI18n_1.maybeUseI18n)(originalSchema, DEFAULT_LOCALES);
-        expect(translatedSchema).toStrictEqual({
-            clientLocale: "de-de",
-            groupNames: {
-                DoB: "dein Geburtstag",
-            },
-            group_title: undefined,
-            properties: originalSchema.properties,
-            i18n: originalSchema.i18n,
-        });
-    });
-    it("correctly applies overrides to certain schema fields", () => {
-        const originalSchema = {
-            i18n: {
-                "en-029": {
-                    year_of_birth: { title: "Your year of birth" },
-                },
-                de: {
-                    // also testing whether it utilizes "de" even tho locale is "de-DE"
-                    year_of_birth: { title: "dein Geburtsjahr", randomProp: 1 },
-                },
-            },
-            properties: {
-                year_of_birth: {
-                    title: "Default field title",
-                    tags: ["group:DoB"],
-                },
-            },
-        };
-        const translatedSchema = (0, maybeUseI18n_1.maybeUseI18n)(originalSchema, DEFAULT_LOCALES);
-        expect(translatedSchema).toStrictEqual({
-            clientLocale: "de", // note how this is 'de', not 'de-de' because the schema defined 'de'
-            groupNames: {},
-            group_title: undefined,
-            properties: {
-                year_of_birth: {
-                    title: "dein Geburtsjahr",
-                    randomProp: 1,
-                    tags: ["group:DoB"],
-                },
-            },
-            i18n: originalSchema.i18n,
-        });
-    });
-});

package/dist/schema/expandSchema/__tests__/processSchema.test.d.ts

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

package/dist/schema/expandSchema/__tests__/processSchema.test.js

@@ -1,326 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const processSchema_1 = require("../processSchema");
-describe("processSchema", () => {
-    it("should correctly merge properties with a reference", async () => {
-        const mock = {
-            schema: {
-                definitions: {
-                    firstname: { $ref: "urn:schema:ss_first_name_01" },
-                },
-                properties: {
-                    first_name: {
-                        allOf: [
-                            { $ref: "#/definitions/firstname" },
-                            {
-                                priority: 10,
-                                duplicateStringField: "from main schema",
-                                tags: ["customTag"],
-                            },
-                        ],
-                    },
-                },
-            },
-        };
-        const allUnexpandedSchema = [
-            mock,
-            {
-                schema_name: "ss_first_name_01",
-                schema: {
-                    properties: {},
-                    tags: ["a tag from the child"],
-                    duplicateStringField: "from sub schema",
-                },
-            },
-        ];
-        const expected = {
-            first_name: {
-                $prop: "first_name",
-                $ref: "ss_first_name_01",
-                priority: 10,
-                duplicateStringField: "from main schema",
-                tags: ["customTag", "a tag from the child"],
-            },
-        };
-        expect((0, processSchema_1.processSchema)(mock.schema, allUnexpandedSchema)).toStrictEqual({
-            properties: expected,
-            required: [],
-            tags: [],
-            verified_fields: undefined,
-            isProfileSchema: false,
-            isSpSchema: false,
-            definitions: mock.schema.definitions, // removed at a later stage
-        });
-    });
-    it("should not expand normal properties", async () => {
-        const getIdentityToken = vi.fn(async () => { });
-        const properties = {
-            first_name: {
-                priority: 10,
-                tags: ["customTag"],
-            },
-        };
-        const actual = (0, processSchema_1.processSchema)({ properties }, []);
-        expect(getIdentityToken).not.toHaveBeenCalled();
-        expect(actual).toStrictEqual({
-            properties: {
-                first_name: {
-                    $prop: "first_name",
-                    priority: 10,
-                    tags: ["customTag"],
-                },
-            },
-            required: [],
-            tags: [],
-            verified_fields: undefined,
-            isProfileSchema: false,
-            isSpSchema: false,
-        });
-    });
-    it("should correctly expand refs from a schema-wide allOf filter", async () => {
-        const mock = {
-            schema: {
-                required: ["a", "b"],
-                definitions: {
-                    firstname: { $ref: "urn:schema:ss_first_name_01" },
-                    lastname: { $ref: "urn:schema:ss_last_name_01" },
-                },
-                allOf: [
-                    { $ref: "#/definitions/firstname" },
-                    { $ref: "#/definitions/lastname" },
-                ],
-                // note how there are no properties on the schema. this is possible if there is an allOf
-            },
-        };
-        const allUnexpandedSchema = [
-            mock,
-            {
-                schema_name: "ss_first_name_01",
-                schema: {
-                    required: ["c", "d"],
-                    properties: { first_name: { type: "string" } },
-                },
-            },
-            {
-                schema_name: "ss_last_name_01",
-                schema: {
-                    required: ["e", "f"],
-                    properties: { last_name: { type: "string" } },
-                },
-            },
-        ];
-        expect((0, processSchema_1.processSchema)(mock.schema, allUnexpandedSchema)).toStrictEqual({
-            required: ["a", "b", "c", "d", "e", "f"],
-            properties: {
-                first_name: { type: "string", $prop: "first_name" },
-                last_name: { type: "string", $prop: "last_name" },
-            },
-            tags: [],
-            verified_fields: undefined,
-            isProfileSchema: false,
-            isSpSchema: false,
-            allOf: mock.schema.allOf, // removed later
-            definitions: mock.schema.definitions, // removed later
-        });
-    });
-    it("handles fields that conditionally show", async () => {
-        const schema = {
-            properties: {},
-            allOf: [
-                {
-                    if: { properties: { country: { enum: ["AU"] } } },
-                    then: {
-                        required: ["sublocality"],
-                        properties: { sublocality: { lookup: "AUSTRALIA" } },
-                    },
-                },
-                {
-                    if: { properties: { country: { enum: ["NZ"] } } },
-                    then: {
-                        properties: { sublocality: { lookup: "NEW ZEALAND" } },
-                    },
-                },
-            ],
-        };
-        expect((0, processSchema_1.processSchema)(schema, [])).toStrictEqual({
-            properties: {
-                // by default it's not shown
-                // it converted the one field into two conditionally shown fields
-                "sublocality <=> country=AU": {
-                    $prop: "sublocality",
-                    if: { country: ["AU"] },
-                    lookup: "AUSTRALIA",
-                },
-                "sublocality <=> country=NZ": {
-                    $prop: "sublocality",
-                    if: { country: ["NZ"] },
-                    lookup: "NEW ZEALAND",
-                },
-            },
-            required: [
-                {
-                    field: "sublocality",
-                    if: {
-                        country: ["AU"],
-                    },
-                },
-            ],
-            tags: [],
-            verified_fields: undefined,
-            isProfileSchema: false,
-            isSpSchema: false,
-            allOf: schema.allOf,
-        });
-    });
-    it("handles fields that conditionally change properties", async () => {
-        const schema = {
-            properties: { sublocality: { lookup: "NONE" } },
-            allOf: [
-                {
-                    if: { properties: { country: { enum: ["AU", "US"] } } },
-                    then: {
-                        required: ["sublocality"],
-                        properties: { sublocality: { lookup: "AUSTRALIA OR US" } },
-                    },
-                },
-                {
-                    if: {
-                        properties: {
-                            country: { enum: ["NZ"] },
-                            island: { enum: ["SouthIsland"] },
-                        },
-                    },
-                    then: {
-                        properties: {
-                            sublocality: { lookup: "NEW ZEALAND AND south island" },
-                        },
-                    },
-                },
-            ],
-        };
-        expect((0, processSchema_1.processSchema)(schema, [])).toStrictEqual({
-            properties: {
-                // it kept the original field but added two conditionally shown fields
-                sublocality: {
-                    $prop: "sublocality",
-                    lookup: "NONE",
-                },
-                "sublocality <=> country=AU|US": {
-                    $prop: "sublocality",
-                    if: { country: ["AU", "US"] },
-                    lookup: "AUSTRALIA OR US",
-                },
-                "sublocality <=> country=NZ & island=SouthIsland": {
-                    $prop: "sublocality",
-                    if: { country: ["NZ"], island: ["SouthIsland"] },
-                    lookup: "NEW ZEALAND AND south island",
-                },
-            },
-            required: [
-                {
-                    field: "sublocality",
-                    if: { country: ["AU", "US"] },
-                },
-            ],
-            tags: [],
-            verified_fields: undefined,
-            isProfileSchema: false,
-            isSpSchema: false,
-            allOf: schema.allOf,
-        });
-    });
-    it("handles fields that are conditionally verifiable", async () => {
-        const schema = {
-            properties: {},
-            allOf: [
-                {
-                    if: { properties: { birth_year: { enum: [17, 18] } } },
-                    then: {
-                        verified_fields: ["first_name"],
-                    },
-                },
-            ],
-        };
-        expect((0, processSchema_1.processSchema)(schema, [])).toStrictEqual({
-            properties: {},
-            required: [],
-            tags: [],
-            verified_fields: [{ field: "first_name", if: { birth_year: [17, 18] } }],
-            isProfileSchema: false,
-            isSpSchema: false,
-            allOf: schema.allOf,
-        });
-    });
-    it("makes the whole schema verifiable if there are any conditionally verifiable fields", async () => {
-        const schema = {
-            properties: {},
-            tags: ["abc"],
-            allOf: [
-                {
-                    if: { properties: { birth_year: { enum: [17, 18] } } },
-                    then: {
-                        tags: ["action:verify", "xyz"],
-                    },
-                },
-            ],
-        };
-        expect((0, processSchema_1.processSchema)(schema, [])).toStrictEqual({
-            properties: {},
-            required: [],
-            tags: ["abc", "action:verify"],
-            verified_fields: undefined,
-            isProfileSchema: false,
-            isSpSchema: false,
-            allOf: schema.allOf,
-        });
-    });
-    it("handles nested allOfs", async () => {
-        const schema = {
-            definitions: {
-                ref_to_MOE_ID: { $ref: "urn:schema:ss_MOE_ID" },
-            },
-            properties: {},
-            allOf: [
-                {
-                    if: { properties: { country: { enum: ["NZ"] } } },
-                    then: {
-                        properties: {
-                            MOE_ID: {
-                                allOf: [
-                                    { $ref: "#/definitions/ref_to_MOE_ID" },
-                                    { title: "MinEdu ID" },
-                                ],
-                            },
-                        },
-                    },
-                },
-            ],
-        };
-        const moeSubSchema = {
-            schema_name: "ss_MOE_ID",
-            schema: {
-                type: "number",
-                properties: {},
-            },
-        };
-        expect((0, processSchema_1.processSchema)(schema, [schema, moeSubSchema])).toStrictEqual({
-            allOf: schema.allOf,
-            definitions: schema.definitions,
-            isProfileSchema: false,
-            isSpSchema: false,
-            properties: {
-                "MOE_ID <=> country=NZ": {
-                    $prop: "MOE_ID",
-                    $ref: "ss_MOE_ID",
-                    if: { country: ["NZ"] },
-                    // it merged in props from 3 different places
-                    title: "MinEdu ID",
-                    type: "number",
-                },
-            },
-            required: [],
-            tags: [],
-            verified_fields: undefined,
-        });
-    });
-});

package/dist/schema/expandSchema/__tests__/sortSchemaProperties.test.d.ts

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