@raytio/core 11.0.0 → 11.1.0

package/dist/schema/expandSchema/maybeUseI18n.js

@@ -0,0 +1,40 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeUseI18n = void 0;
+const ramda_1 = require("ramda");
+const i18n_1 = require("./i18n");
+const getGroupNames = (0, ramda_1.pipe)(ramda_1.toPairs, 
+// @ts-expect-error
+(0, ramda_1.filter)(([key]) => key.startsWith("group:")), 
+// @ts-expect-error
+(0, ramda_1.map)(([key, value]) => [key.replace("group:", ""), value.title]), ramda_1.fromPairs);
+const maybeUseI18n = (schema, userLocales) => {
+    var _a;
+    if (!schema.i18n)
+        return schema;
+    // try to find an exact match in schema.i18n. The fallback: if the schema
+    // only has en-nz, but the user speaks en-US, then use en-nz.
+    const localeToUse = (0, i18n_1.findSuitableLocale)(Object.keys(schema.i18n), userLocales);
+    // the schema has an i18n property, but it doesn't include a lang that the user speaks
+    if (!localeToUse)
+        return schema;
+    const _b = schema.i18n[localeToUse], { $schema } = _b, translations = __rest(_b, ["$schema"]);
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, schema), { clientLocale: localeToUse }), $schema), { group_title: schema.schema_group &&
+            (((_a = translations[schema.schema_group]) === null || _a === void 0 ? void 0 : _a.title_plural) || schema.schema_group), 
+        // add a `groupNames` property to the schema
+        groupNames: getGroupNames(translations), 
+        // maybe apply translations per field
+        properties: (0, ramda_1.mapObjIndexed)((field, fieldName) => (Object.assign(Object.assign({}, field), translations[fieldName])), schema.properties) });
+};
+exports.maybeUseI18n = maybeUseI18n;

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

@@ -0,0 +1,4 @@
+import { Schema, WrappedSchema } from "@raytio/types";
+export declare const processSchema: (schema: WrappedSchema["schema"] & {
+    version: string;
+}, allUnexpandedSchemas: WrappedSchema[]) => Schema;

package/dist/schema/expandSchema/processSchema.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSchema = void 0;
+const ramda_1 = require("ramda");
+const constants_1 = require("./constants");
+const sortSchemaProperties_1 = require("./sortSchemaProperties");
+const util_1 = require("./util");
+const convertIfEnum = (0, ramda_1.mapObjIndexed)(y => Object.values(y)[0]);
+const processSchema = (schema, allUnexpandedSchemas) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const expandField = (property, key) => {
+        var _a, _b;
+        if (!property.allOf)
+            return Object.assign(Object.assign({}, property), { $prop: key });
+        // this property references another schema
+        const [{ $ref }, custom] = property.allOf;
+        if (!$ref)
+            throw new Error("allOf missing $ref");
+        const subSchemaName = (0, sortSchemaProperties_1.getNidFromUrn)((_a = schema.definitions) === null || _a === void 0 ? void 0 : _a[$ref.split("/")[2]].$ref);
+        if (!subSchemaName)
+            throw new Error("Invalid schema");
+        const subSchema = (_b = allUnexpandedSchemas.find(s => s.name === subSchemaName)) === null || _b === void 0 ? void 0 : _b.schema;
+        if (!subSchema) {
+            throw new Error(`Could not resolve subschema '${subSchemaName}'`);
+        }
+        return (0, ramda_1.pipe)((0, ramda_1.dissoc)("properties"), // subSchema don't have properties so remove
+        (0, ramda_1.mergeWith)((main, sub) => {
+            // merge custom props in; concatting arrays, but picking
+            // the main value only for strings.
+            if (typeof main === "string")
+                return main;
+            return [...main, ...sub];
+        }, custom), (f) => (Object.assign(Object.assign({}, f), { $ref: subSchemaName })), // add $ref to the subSchema
+        // add $ref to the subSchema
+        field => (Object.assign(Object.assign({}, field), { $prop: key })))(subSchema);
+    };
+    const exandedProps = (0, ramda_1.mapObjIndexed)(expandField, schema.properties);
+    const allOfRequired = [];
+    const globallyReferencedSubSchema = (_b = (_a = schema.allOf) === null || _a === void 0 ? void 0 : _a.reduce((ac, { $ref }) => {
+        var _a, _b;
+        // TODO: should this block of code re-use `expandField`?
+        if (!$ref)
+            return ac; // this allOf entry is not a reference
+        const subSchemaName = (0, sortSchemaProperties_1.getNidFromUrn)((_a = schema.definitions) === null || _a === void 0 ? void 0 : _a[$ref.split("/")[2]].$ref);
+        if (!subSchemaName)
+            throw new Error("Invalid schema");
+        const subSchema = (_b = allUnexpandedSchemas.find(s => s.name === subSchemaName)) === null || _b === void 0 ? void 0 : _b.schema;
+        if (!subSchema) {
+            throw new Error(`Could not resolve subschema '${subSchemaName}'`);
+        }
+        if (subSchema.required) {
+            // eslint-disable-next-line fp/no-mutating-methods
+            allOfRequired.push(...subSchema.required);
+        }
+        return Object.assign(Object.assign({}, ac), (0, ramda_1.mapObjIndexed)((field, fieldName) => (Object.assign(Object.assign({}, field), { $prop: fieldName })), subSchema.properties));
+    }, {})) !== null && _b !== void 0 ? _b : {};
+    // IF properties THEN required
+    const conditionallyRequired = ((_c = schema.allOf) === null || _c === void 0 ? void 0 : _c.filter(x => { var _a, _b; return ((_a = x.if) === null || _a === void 0 ? void 0 : _a.properties) && ((_b = x.then) === null || _b === void 0 ? void 0 : _b.required); }).flatMap(x => x.then.required.map(field => ({
+        field: field,
+        if: convertIfEnum(x.if.properties),
+    })))) || [];
+    // IF properties THEN properties
+    const conditionalProperties = ((_d = schema.allOf) === null || _d === void 0 ? void 0 : _d.filter(x => { var _a, _b; return ((_a = x.if) === null || _a === void 0 ? void 0 : _a.properties) && ((_b = x.then) === null || _b === void 0 ? void 0 : _b.properties); }).reduce((ac, ifThen) => {
+        const props = Object.fromEntries(Object.entries(ifThen.then.properties).map(([k, v]) => {
+            const iff = convertIfEnum(ifThen.if.properties);
+            return [
+                `${k} <=> ${(0, util_1.getConditionId)(iff)}`,
+                Object.assign(Object.assign({}, expandField(v, k)), { if: iff, $prop: k }),
+            ];
+        }));
+        return Object.assign(Object.assign({}, ac), props);
+    }, {})) || {};
+    // IF properties THEN verifiable
+    const conditionallyVerifiable = ((_e = schema.allOf) === null || _e === void 0 ? void 0 : _e.filter(x => { var _a, _b; return ((_a = x.if) === null || _a === void 0 ? void 0 : _a.properties) && ((_b = x.then) === null || _b === void 0 ? void 0 : _b.verified_fields); }).flatMap(x => x.then.verified_fields.map(field => ({
+        field: field,
+        if: convertIfEnum(x.if.properties),
+    })))) || [];
+    const verifiedFields = (0, ramda_1.uniq)([
+        ...(schema.verified_fields || []),
+        ...conditionallyVerifiable,
+    ]);
+    const shouldBeConditionallyVerified = (_f = schema.allOf) === null || _f === void 0 ? void 0 : _f.some(x => { var _a, _b; return (_b = (_a = x.then) === null || _a === void 0 ? void 0 : _a.tags) === null || _b === void 0 ? void 0 : _b.includes("action:verify"); });
+    return Object.assign(Object.assign({}, schema), { properties: Object.assign(Object.assign(Object.assign({}, exandedProps), globallyReferencedSubSchema), conditionalProperties), required: (0, ramda_1.uniq)([
+            ...(schema.required || []),
+            ...allOfRequired,
+            ...conditionallyRequired,
+        ]), 
+        // important that it's undefined instead of empty array so that it's falsy
+        verified_fields: verifiedFields.length ? verifiedFields : undefined, tags: (0, ramda_1.uniq)([
+            ...(schema.tags || []),
+            ...(shouldBeConditionallyVerified ? ["action:verify"] : []),
+        ]), isProfileSchema: !constants_1.TAG_DENYLIST.some(tag => { var _a; return (_a = schema.tags) === null || _a === void 0 ? void 0 : _a.includes(tag); }) && !!schema.title, isSpSchema: ((_g = schema.tags) === null || _g === void 0 ? void 0 : _g.includes("type:service_provider")) || false });
+};
+exports.processSchema = processSchema;

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

@@ -0,0 +1,119 @@
+import { Schema } from "@raytio/types";
+export declare const removePrivateFields: (schema: Schema) => {
+    properties: Record<string, Omit<import("@raytio/types").SchemaField, "$id" | "allOf" | "$schema" | "definitions">>;
+    type?: import("@raytio/types").DataTypes | undefined;
+    name: string;
+    title: string;
+    description: string;
+    title_plural?: string | undefined;
+    schema_group?: string | undefined;
+    tags?: import("@raytio/types").SchemaTag[] | undefined;
+    i18n?: {
+        [locale: string]: {
+            [fieldNameOrGroupName: string]: import("@raytio/types").ServerSchemaField & {
+                title_plural?: string | undefined;
+            };
+            $schema: {
+                title: string;
+                title_plural?: string | undefined;
+                description?: string | undefined;
+            };
+            $loading_extract: {
+                title: string;
+            };
+            $loading_verify: {
+                title: string;
+            };
+            $loading_save: {
+                title: string;
+            };
+            $loading_update: {
+                title: string;
+            };
+            $loading_upload: {
+                title: string;
+            };
+            $loading_create_sub_obj: {
+                title: string;
+            };
+            $loading_permission: {
+                title: string;
+            };
+            $loading_link_to_person: {
+                title: string;
+            };
+            $loading_delete_pending_ver: {
+                title: string;
+            };
+            $loading_pending_ver_resubmit: {
+                title: string;
+            };
+            $loading_long_verification_message: {
+                title?: string | undefined;
+                description?: string | undefined;
+            };
+        };
+    } | undefined;
+    relationships?: {
+        relationship_name: string;
+        direction: "from";
+        type: string;
+        required_relationship?: boolean | undefined;
+        oneOf?: string[] | undefined;
+        anyOf?: string[] | undefined;
+        multiple?: boolean | undefined;
+        properties?: {
+            [fieldName: string]: import("@raytio/types").SchemaField;
+        } | undefined;
+        required?: string[] | undefined;
+    }[] | undefined;
+    display?: {
+        head_main?: {
+            fields: string[];
+            format?: string | undefined;
+        } | undefined;
+        head_sub?: {
+            fields: string[];
+            format?: string | undefined;
+        } | undefined;
+        expand?: {
+            fields: string[];
+            label: string;
+        }[] | undefined;
+    } | undefined;
+    onboard_properties?: {
+        profile_objects?: {
+            schema_name: string;
+            properties: Record<string, unknown>;
+        }[] | undefined;
+        relationships?: {
+            from: string;
+            to: string;
+            type: string;
+            properties?: Record<string, string> | undefined;
+        }[] | undefined;
+        organizations?: {
+            properties: import("@raytio/types").Organization;
+            access_applications?: {
+                properties: Omit<import("@raytio/types").AA, "org_id">;
+                links?: {
+                    description: string;
+                    wizardConfig: Omit<import("@raytio/types").WizardConfig, "a_id">;
+                }[] | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        return_to?: string | undefined;
+    } | undefined;
+    group_title?: string | undefined;
+    verified_fields?: (string | import("@raytio/types").ConditionallyRequired)[] | undefined;
+    required?: (string | import("@raytio/types").ConditionallyRequired)[] | undefined;
+    wasExpandedByClient?: boolean | undefined;
+    start_date?: string | undefined;
+    end_date?: string | undefined;
+    groupNames?: Record<string, string> | undefined;
+    clientLocale?: string | undefined;
+    version: string;
+    timing?: Record<"extract" | "live_person" | "verify_pending_delay", number> | undefined;
+    isProfileSchema?: boolean | undefined;
+    isSpSchema?: boolean | undefined;
+};

package/dist/schema/expandSchema/removePrivateFields.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removePrivateFields = void 0;
+const ramda_1 = require("ramda");
+/** we don't expose these to the rest of the client to avoid confusion or misusing them */
+const PRIVATE_FIELDS = [
+    "$id",
+    "$schema",
+    "definitions",
+    "allOf",
+];
+const removePrivateFields = (schema) => (Object.assign(Object.assign({}, (0, ramda_1.omit)(PRIVATE_FIELDS, schema)), { 
+    // and from each field in `properties`
+    properties: (0, ramda_1.mapObjIndexed)((0, ramda_1.omit)(PRIVATE_FIELDS), schema.properties) }));
+exports.removePrivateFields = removePrivateFields;

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

@@ -0,0 +1,21 @@
+import { NId, SchemaField, Urn } from "@raytio/types";
+/** two overloads - if you provide undefined, you might get undefined back */
+export declare const getNidFromUrn: {
+    (urn: Urn): NId;
+    (urn: Urn | undefined): NId | undefined;
+};
+type Key = string;
+type Tag = string;
+type Section = {
+    title: Tag;
+    items: SchemaField[];
+};
+/** @ignore */
+export declare const NO_TAG = "-notag-common";
+/**
+ * Schema properties are an object, so they need to be converted into an
+ * array, grouped by the group tag, and then sorted based on the `priority`
+ * attribute within their group.
+ */
+export declare function sortSchemaProperties(properties: Record<Key, SchemaField>): Section[];
+export {};

package/dist/schema/expandSchema/sortSchemaProperties.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortSchemaProperties = exports.NO_TAG = exports.getNidFromUrn = void 0;
+const ramda_1 = require("ramda");
+/** two overloads - if you provide undefined, you might get undefined back */
+exports.getNidFromUrn = ((urn) => urn === null || urn === void 0 ? void 0 : urn.split(":")[2]);
+/** @ignore */
+exports.NO_TAG = "-notag-common";
+/**
+ * Schema properties are an object, so they need to be converted into an
+ * array, grouped by the group tag, and then sorted based on the `priority`
+ * attribute within their group.
+ */
+function sortSchemaProperties(properties) {
+    const tagToSection = (field) => {
+        var _a;
+        // if there is a tag prefixed with `group:`, then use it
+        const groupTags = [
+            ...new Set((_a = field.tags) === null || _a === void 0 ? void 0 : _a.filter(tag => tag.startsWith("group:"))),
+        ];
+        if (groupTags === null || groupTags === void 0 ? void 0 : groupTags.length) {
+            const group = groupTags[0].replace("group:", "");
+            return group;
+        }
+        // if there is no group tag, put all those fields together in a group called "common"
+        return exports.NO_TAG;
+    };
+    const assocAsArray = (acum, curr) => (0, ramda_1.mergeWithKey)((k, a, b) => [...a, ...b], acum, curr);
+    const keyedByTag = Object.values((0, ramda_1.mapObjIndexed)((field, fieldName) => ({
+        // add prop anyway, just incase it's missing
+        [tagToSection(field)]: Object.assign(Object.assign({}, field), { $prop: fieldName }),
+    }), properties));
+    const keyedByTagSingleton = (0, ramda_1.map)(a => ({ [Object.keys(a)[0]]: [a[Object.keys(a)[0]]] }), keyedByTag);
+    const unsorted = (0, ramda_1.reduce)(assocAsArray, {}, keyedByTagSingleton);
+    const objWithSortedChildren = (0, ramda_1.mapObjIndexed)(fieldObjList => (0, ramda_1.sort)((a, b) => { var _a, _b; return ((_a = a.priority) !== null && _a !== void 0 ? _a : 0) - ((_b = b.priority) !== null && _b !== void 0 ? _b : 0); }, fieldObjList), unsorted);
+    // defined seperately because typescript gets confused
+    const unsortedFinal = Object.entries(objWithSortedChildren).map(([title, items]) => ({ title, items: (0, ramda_1.uniqBy)(f => f.$prop, items) }));
+    return (0, ramda_1.sortBy)(x => x.items[0].priority, unsortedFinal); // sort by priority of first child
+}
+exports.sortSchemaProperties = sortSchemaProperties;

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

@@ -0,0 +1,6 @@
+import { WrappedSchema } from "@raytio/types";
+export declare function unwrapSchema(wrapped: WrappedSchema): WrappedSchema["schema"] & {
+    version: string;
+    start_date?: string;
+    end_date?: string;
+};

package/dist/schema/expandSchema/unwrapSchema.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapSchema = void 0;
+function unwrapSchema(wrapped) {
+    return Object.assign(Object.assign({}, wrapped.schema), { name: wrapped.name, start_date: wrapped.start_date, end_date: wrapped.end_date, version: wrapped.version });
+}
+exports.unwrapSchema = unwrapSchema;

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

@@ -0,0 +1,6 @@
+/**
+ * this is NOT meant to be machine readable, just unique.
+ * and it should make logical sense to a human. It is LOSSY,
+ * e.g. null and '' (empty string) become the same thing.
+ */
+export declare const getConditionId: (iff: Record<string, string[]>) => string;

package/dist/schema/expandSchema/util.js

@@ -0,0 +1,15 @@
+"use strict";
+// this file is not exposed to the rest of the app, it's util functions
+// used by other schema helpers
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConditionId = void 0;
+const ramda_1 = require("ramda");
+// the sorting algorithm isn't important, as long as it's consistent
+const sort = (0, ramda_1.sortBy)((x) => x);
+/**
+ * this is NOT meant to be machine readable, just unique.
+ * and it should make logical sense to a human. It is LOSSY,
+ * e.g. null and '' (empty string) become the same thing.
+ */
+const getConditionId = (iff) => sort(Object.entries(iff).map(([kk, vv]) => `${kk}=${sort(vv).join("|")}`)).join(" & ");
+exports.getConditionId = getConditionId;

package/dist/schema/index.d.ts

@@ -1 +1,2 @@
+export * from "./expandSchema";
 export * from "./labels";

package/dist/schema/index.js

@@ -14,4 +14,5 @@ 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 });
+__exportStar(require("./expandSchema"), exports);
 __exportStar(require("./labels"), exports);

package/dist/verifications/safeHarbour.d.ts

@@ -1,4 +1,4 @@
-import { ProfileObject, RealVer, Schema } from "@raytio/types";
+import { ProfileObject, RealVer, SafeHarbourCode, Schema } from "@raytio/types";
 /** an object listing the `xId`s for each SafeHarbourCode */
 export type SafeHarbourObj = Partial<Record<SafeHarbourCode, string[]>>;
 /** the response from {@link calcSafeHarbourScore} */

package/dist/verifications/safeHarbour.js

@@ -5,13 +5,6 @@ const ramda_1 = require("ramda");
 const types_1 = require("@raytio/types");
 const getPOVerification_1 = require("./getPOVerification");
 const schema_1 = require("../schema");
-/** @internal see #659 */
-var SafeHarbourCode;
-(function (SafeHarbourCode) {
-    SafeHarbourCode["M1"] = "M1";
-    SafeHarbourCode["M2"] = "M2";
-    SafeHarbourCode["N1"] = "N1";
-})(SafeHarbourCode || (SafeHarbourCode = {}));
 /**
  * @internal
  * we filter to only include the POs where all the mutual fields match the
@@ -43,11 +36,11 @@ async function getFlags({ person, profileObjects, realVers, getSchema, }) {
         .filter((x) => !!x);
     // in case there are somehow duplicates (see #922)
     return (0, ramda_1.uniqBy)(x => x.nID, relevantVers)
-        .filter(ver => { var _a; return (_a = ver.metadata) === null || _a === void 0 ? void 0 : _a["safeHarbourScore"]; })
+        .filter(ver => { var _a; return (_a = ver.metadata) === null || _a === void 0 ? void 0 : _a.safeHarbourScore; })
         .reduce((ac, ver) => {
-        var _a, _b;
-        const key = (_a = ver.metadata) === null || _a === void 0 ? void 0 : _a["safeHarbourScore"];
-        if ((_b = ac[key]) === null || _b === void 0 ? void 0 : _b.includes(ver.xId))
+        var _a;
+        const key = ver.metadata.safeHarbourScore;
+        if ((_a = ac[key]) === null || _a === void 0 ? void 0 : _a.includes(ver.xId))
             return ac;
         return Object.assign(Object.assign({}, ac), { [key]: [...(ac[key] || []), ver.xId] });
     }, {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raytio/core",
-  "version": "11.0.0",
+  "version": "11.1.0",
   "license": "MIT",
   "main": "index",
   "types": "index",
@@ -21,7 +21,7 @@
     "ramda": "0.29.0"
   },
   "devDependencies": {
-    "@types/ramda": "0.28.24",
+    "@types/ramda": "0.29.0",
     "jest": "29.5.0",
     "ts-jest": "29.1.0"
   },