@raytio/core 11.5.0 → 11.7.0

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 {};

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

@@ -1,182 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sortSchemaProperties_1 = require("../sortSchemaProperties");
-describe("sortSchemaProperties tests", () => {
-    it("correctly sorts the fields by priority and groups", () => {
-        const actual = (0, sortSchemaProperties_1.sortSchemaProperties)({
-            first_name: {
-                tags: ["group:name"],
-                priority: 10,
-                n_id: "first_name",
-                $prop: "first_name",
-            },
-            last_name: {
-                tags: ["group:name"],
-                priority: 20,
-                n_id: "last_name",
-                $prop: "last_name",
-            },
-            gender: {
-                tags: ["globally_unique_field", "group:gender"],
-                priority: 5,
-                n_id: "gender",
-                $prop: "gender",
-            },
-            oof: { priority: 30, n_id: "abc123", $prop: "oof" },
-            another_field_without_tags_and_no_nid: {
-                priority: 50,
-                $prop: "another_field_without_tags_and_no_nid",
-            },
-            another_field_without_tags: {
-                priority: 40,
-                n_id: "xyz789",
-                $prop: "another_field_without_tags",
-            },
-            middle_name: {
-                tags: ["group:name"],
-                priority: 15,
-                n_id: "middle_name",
-                $prop: "middle_name",
-            },
-        });
-        const expected = [
-            {
-                title: "gender",
-                items: [
-                    {
-                        $prop: "gender",
-                        priority: 5,
-                        tags: ["globally_unique_field", "group:gender"],
-                        n_id: "gender",
-                    },
-                ],
-            },
-            {
-                title: "name",
-                items: [
-                    {
-                        priority: 10,
-                        tags: ["group:name"],
-                        n_id: "first_name",
-                        $prop: "first_name",
-                    },
-                    {
-                        priority: 15,
-                        tags: ["group:name"],
-                        n_id: "middle_name",
-                        $prop: "middle_name",
-                    },
-                    {
-                        priority: 20,
-                        tags: ["group:name"],
-                        n_id: "last_name",
-                        $prop: "last_name",
-                    },
-                ],
-            },
-            {
-                title: "-notag-common",
-                items: [
-                    { priority: 30, n_id: "abc123", $prop: "oof" },
-                    { priority: 40, n_id: "xyz789", $prop: "another_field_without_tags" },
-                    { priority: 50, $prop: "another_field_without_tags_and_no_nid" },
-                ],
-            },
-        ];
-        expect(actual).toStrictEqual(expected);
-    });
-    it("Deals with nested data", () => {
-        const result = (0, sortSchemaProperties_1.sortSchemaProperties)({
-            id: {
-                priority: 100,
-                tags: ["group:provider_product"],
-                type: "string",
-                description: "The unique id of the product",
-                title: "Product ID",
-                $prop: "id",
-            },
-            metadata: {
-                $prop: "metadata",
-                properties: {},
-                items: {
-                    id: {
-                        priority: 100,
-                        tags: ["group:provider_product"],
-                        type: "string",
-                        description: "The unique id of the product",
-                        title: "Product ID",
-                    },
-                },
-                type: "object",
-                title: "Product details",
-                priority: 300,
-                tags: ["group:provider_product"],
-                description: "Additional information about the product",
-            },
-        });
-        expect(result).toStrictEqual([
-            {
-                items: [
-                    {
-                        $prop: "id",
-                        description: "The unique id of the product",
-                        priority: 100,
-                        tags: ["group:provider_product"],
-                        title: "Product ID",
-                        type: "string",
-                    },
-                    {
-                        $prop: "metadata",
-                        description: "Additional information about the product",
-                        items: {
-                            id: {
-                                description: "The unique id of the product",
-                                priority: 100,
-                                tags: ["group:provider_product"],
-                                title: "Product ID",
-                                type: "string",
-                            },
-                        },
-                        priority: 300,
-                        properties: {},
-                        tags: ["group:provider_product"],
-                        title: "Product details",
-                        type: "object",
-                    },
-                ],
-                title: "provider_product",
-            },
-        ]);
-    });
-    it("makes use of sub groups within the same group", () => {
-        const actual = (0, sortSchemaProperties_1.sortSchemaProperties)({
-            date_of_birth: { $prop: "date_of_birth", tags: ["group:date:birth"] },
-            month_of_birth: { $prop: "month_of_birth", tags: ["group:date:birth"] },
-            year_of_birth: { $prop: "year_of_birth", tags: ["group:date:birth"] },
-            date_of_expiry: { $prop: "date_of_expiry", tags: ["group:date:expiry"] },
-            month_of_expiry: {
-                $prop: "month_of_expiry",
-                tags: ["group:date:expiry"],
-            },
-            year_of_expiry: { $prop: "year_of_expiry", tags: ["group:date:expiry"] },
-        });
-        expect(actual).toStrictEqual([
-            {
-                title: "date:birth",
-                items: [
-                    { $prop: "date_of_birth", tags: ["group:date:birth"] },
-                    { $prop: "month_of_birth", tags: ["group:date:birth"] },
-                    { $prop: "year_of_birth", tags: ["group:date:birth"] },
-                ],
-            },
-            {
-                title: "date:expiry",
-                items: [
-                    { $prop: "date_of_expiry", tags: ["group:date:expiry"] },
-                    { $prop: "month_of_expiry", tags: ["group:date:expiry"] },
-                    { $prop: "year_of_expiry", tags: ["group:date:expiry"] },
-                ],
-            },
-        ]);
-    });
-});

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

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

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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../util");
-describe("getConditionId", () => {
-    it.each `
-    iff                                         | id
-    ${{ country: ["NZ"] }}                      | ${"country=NZ"}
-    ${{ country: ["NZ", "AU"] }}                | ${"country=AU|NZ"}
-    ${{ country: ["AU", "NZ"] }}                | ${"country=AU|NZ"}
-    ${{ country: ["NZ"], age: [17] }}           | ${"age=17 & country=NZ"}
-    ${{ country: ["NZ"], age: [17, 18] }}       | ${"age=17|18 & country=NZ"}
-    ${{ country: ["NZ", "AU"], age: [17, 18] }} | ${"age=17|18 & country=AU|NZ"}
-    ${{}}                                       | ${""}
-    ${{ country: [] }}                          | ${"country="}
-    ${{ country: [], age: [] }}                 | ${"age= & country="}
-  `("generates IDs ($id)", ({ iff, id }) => {
-        expect((0, util_1.getConditionId)(iff)).toBe(id);
-    });
-});

package/dist/verifications/cleanInstance.d.ts

@@ -1,9 +0,0 @@
-import { Instance } from "@raytio/types";
-/**
- * The API response from share/v2/access_application/instance/:iId
- * returns a complicated hashed_n_id format, so you need to clean up
- * the API response using this function as soon as possible.
- *
- * We relace `hashed_n_id`s with a string `HASHED::{NId}::{AId}`
- */
-export declare function cleanInstance(instance: Instance): Instance;

package/dist/verifications/cleanInstance.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanInstance = void 0;
-const ramda_1 = require("ramda");
-/**
- * The API response from share/v2/access_application/instance/:iId
- * returns a complicated hashed_n_id format, so you need to clean up
- * the API response using this function as soon as possible.
- *
- * We relace `hashed_n_id`s with a string `HASHED::{NId}::{AId}`
- */
-function cleanInstance(instance) {
-    return Object.assign(Object.assign({}, instance), { profile_objects: instance.profile_objects.map((PO) => (Object.assign(Object.assign({}, (0, ramda_1.omit)(["hashed_n_id"], PO)), { n_id: PO.n_id || `HASHED::${PO.hashed_n_id}::${instance.a_id}` }))) });
-}
-exports.cleanInstance = cleanInstance;

package/dist/verifications/verifyCheck/__tests__/getOwnRealVerifications.test.d.ts

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