@raytio/core 10.1.0 → 11.1.0

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

@@ -0,0 +1,326 @@
+"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,
+            {
+                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 = jest.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,
+            {
+                name: "ss_first_name_01",
+                schema: {
+                    required: ["c", "d"],
+                    properties: { first_name: { type: "string" } },
+                },
+            },
+            {
+                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,
+            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 = {
+            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

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

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

@@ -0,0 +1,182 @@
+"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

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

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

@@ -0,0 +1,19 @@
+"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/schema/expandSchema/addLoadingTimes.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "@raytio/types";
+export declare const addLoadingTimes: (schema: Schema) => Schema;

package/dist/schema/expandSchema/addLoadingTimes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLoadingTimes = void 0;
+const addLoadingTimes = (schema) => {
+    var _a;
+    const timeTags = (_a = schema.tags) === null || _a === void 0 ? void 0 : _a.filter(x => x.startsWith("time:")).map(tag => {
+        const [, name, time] = tag.split(":");
+        return [name, +time];
+    });
+    return Object.assign(Object.assign({}, schema), { timing: Object.fromEntries(timeTags || []) });
+};
+exports.addLoadingTimes = addLoadingTimes;

package/dist/schema/expandSchema/constants.d.ts

@@ -0,0 +1,2 @@
+import { SchemaTag } from "@raytio/types";
+export declare const TAG_DENYLIST: SchemaTag[];

package/dist/schema/expandSchema/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAG_DENYLIST = void 0;
+// if a schema has any of these tags, it will not be shown on the user profile
+exports.TAG_DENYLIST = [
+    "type:client_only",
+    "type:globally_unique_field",
+    "type:marketplace",
+    "type:service_offer",
+    "type:service_provider",
+];

package/dist/schema/expandSchema/expandSchema.d.ts

@@ -0,0 +1,7 @@
+import { Schema, WrappedSchema } from "@raytio/types";
+/**
+ * ❣️ This is the main function to transform a schema from
+ * the JSON that the API returns, into a `Schema` object that's useful
+ * to the client.
+ */
+export declare function expandSchema(wrappedSchema: WrappedSchema, allUnexpandedSchemas: WrappedSchema[], userLocales: readonly string[]): Schema;

package/dist/schema/expandSchema/expandSchema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandSchema = void 0;
+const addLoadingTimes_1 = require("./addLoadingTimes");
+const maybeUseI18n_1 = require("./maybeUseI18n");
+const processSchema_1 = require("./processSchema");
+const removePrivateFields_1 = require("./removePrivateFields");
+const unwrapSchema_1 = require("./unwrapSchema");
+/**
+ * ❣️ This is the main function to transform a schema from
+ * the JSON that the API returns, into a `Schema` object that's useful
+ * to the client.
+ */
+function expandSchema(wrappedSchema, allUnexpandedSchemas, userLocales) {
+    // TODO: use Ramda's pipe
+    const schema = (0, removePrivateFields_1.removePrivateFields)((0, maybeUseI18n_1.maybeUseI18n)((0, addLoadingTimes_1.addLoadingTimes)((0, processSchema_1.processSchema)((0, unwrapSchema_1.unwrapSchema)(wrappedSchema), allUnexpandedSchemas)), userLocales));
+    return Object.assign({ wasExpandedByClient: true }, schema);
+}
+exports.expandSchema = expandSchema;

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

@@ -0,0 +1,5 @@
+/**
+ * Selects the most suitable locale to use from a list of options.
+ * Returns undefined if there is no language that the user speaks
+ */
+export declare const findSuitableLocale: (options: string[], langs: readonly string[]) => string | undefined;

package/dist/schema/expandSchema/i18n.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSuitableLocale = exports.getAllLocales = void 0;
+const ramda_1 = require("ramda");
+/** @deprecated @internal exported only for unit tests, use `findSuitableLocale` instead */
+const getAllLocales = (langs) => (0, ramda_1.uniq)(langs.flatMap(locale => [
+    locale.toLowerCase(),
+    locale.toLowerCase().split("-")[0],
+]));
+exports.getAllLocales = getAllLocales;
+/**
+ * Selects the most suitable locale to use from a list of options.
+ * Returns undefined if there is no language that the user speaks
+ */
+const findSuitableLocale = (options, langs) => {
+    const userLocales = (0, exports.getAllLocales)(langs);
+    return (userLocales.find(locale => options.includes(locale)) ||
+        options.find(locale => userLocales.includes(locale.split("-")[0])));
+};
+exports.findSuitableLocale = findSuitableLocale;

package/dist/schema/expandSchema/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./expandSchema";
+export * from "./sortSchemaProperties";
+export { findSuitableLocale } from "./i18n";

package/dist/schema/expandSchema/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSuitableLocale = void 0;
+__exportStar(require("./expandSchema"), exports);
+__exportStar(require("./sortSchemaProperties"), exports);
+var i18n_1 = require("./i18n");
+Object.defineProperty(exports, "findSuitableLocale", { enumerable: true, get: function () { return i18n_1.findSuitableLocale; } });

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

@@ -0,0 +1,2 @@
+import { Schema } from "@raytio/types";
+export declare const maybeUseI18n: (schema: Schema, userLocales: readonly string[]) => Schema;