@raytio/core 11.0.0 → 11.2.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,3 @@
+import { Schema, WrappedSchema } from "@raytio/types";
+import type { unwrapSchema } from "./unwrapSchema";
+export declare const processSchema: (schema: ReturnType<typeof unwrapSchema>, 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.schema_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.schema_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,121 @@
+import { Schema } from "@raytio/types";
+export declare const removePrivateFields: (schema: Schema) => {
+    properties: Record<string, Omit<import("@raytio/types").SchemaField, "$id" | "allOf" | "$schema" | "definitions">>;
+    title: string;
+    description: string;
+    description_decorator?: "md" | undefined;
+    schema_type?: import("@raytio/types").SchemaType | undefined;
+    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;
+    name: string;
+    type?: import("@raytio/types").DataTypes | 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 type ClientFields = {
+    version: string;
+    name: string;
+};
+export declare function unwrapSchema(wrapped: WrappedSchema): WrappedSchema["schema"] & Pick<WrappedSchema, "start_date" | "end_date" | "schema_type"> & ClientFields;

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.schema_name, start_date: wrapped.start_date, end_date: wrapped.end_date, version: wrapped.schema_version, schema_type: wrapped.schema_type });
+}
+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/testHelpers.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+/** like {@link Partial} but applies to all deep properties */
+export type DeepPartial<T> = T | (T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T extends (infer U)[] ? DeepPartial<U>[] : T);
+/** tells typescript that this function is mocked */
+export declare const m: (func: unknown) => jest.Mock<any, any, any>;
+/** helper to let us define type-safe partial mocks */
+export declare const deepPartial: <T>(partial: DeepPartial<T>) => T;

package/dist/testHelpers.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepPartial = exports.m = void 0;
+/** tells typescript that this function is mocked */
+const m = (func) => func;
+exports.m = m;
+/** helper to let us define type-safe partial mocks */
+const deepPartial = (partial) => partial;
+exports.deepPartial = deepPartial;

package/dist/verifications/getPOVerification.js

@@ -55,10 +55,13 @@ function getPOVerification({ PO, schema, realVers, }) {
         if (pertainingVers.length && pertainingVers.every(x => x.expired)) {
             return types_1.FieldVerification.Expired;
         }
-        if (pertainingVers.some(x => !x.verified)) {
+        // the if statement above checks if every ver is expired. It is possible
+        // that only some are expired, so filter out those ones.
+        const nonExpiredPertainingVers = pertainingVers.filter(x => !x.expired);
+        if (nonExpiredPertainingVers.some(x => !x.verified)) {
             return types_1.FieldVerification.VerifiedFalse;
         }
-        return pertainingVers.length
+        return nonExpiredPertainingVers.length
             ? types_1.FieldVerification.Verified
             : types_1.FieldVerification.NotVerified;
     }, shouldBeVerifiedProps);
@@ -89,6 +92,7 @@ function getPOVerification({ PO, schema, realVers, }) {
         nId: PO.n_id,
         realVers,
         shouldBeVerifiedProps,
+        verificationStatus: status,
     });
     // find the earliest expiry date if there is one
     const maybeExpiryDate = ((_c = (0, ramda_1.sortBy)(ver => +ver.expired, realVers.filter(ver => ver.belongsToNId === PO.n_id && ver.expired))[0]) === null || _c === void 0 ? void 0 : _c.expired) || undefined;

package/dist/verifications/getVerifiedBy.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVerifiedBy = void 0;
+const types_1 = require("@raytio/types");
 const ramda_1 = require("ramda");
 const maybeRereference_1 = require("./maybeRereference");
 // we should probably document this
 /** @internal */
-const getVerifiedBy = ({ nId, realVers, shouldBeVerifiedProps, }) => {
+const getVerifiedBy = ({ nId, realVers, shouldBeVerifiedProps, verificationStatus, }) => {
     const mayBeVerifiedFields = Object.keys(shouldBeVerifiedProps);
     const pertainingVers = realVers
+        // for valid verifications, we filter out the information that came from
+        // now expired sources. We only ever consider expired source if the verification
+        // itself is expired.
+        .filter(realVer => realVer.expired ? verificationStatus === types_1.POVerification.Expired : true)
         .filter(x => mayBeVerifiedFields.includes(x.fieldName) &&
         // using ramda's `equals` because this needs to work for objects/arrays
         (0, ramda_1.equals)((0, maybeRereference_1.maybeRereference)(shouldBeVerifiedProps[x.fieldName]), (0, maybeRereference_1.maybeRereference)(x.value)) &&

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/dist/verifications/verifyCheck/__tests__/getOwnRealVerifications.test.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const __1 = require("..");
 const operations_1 = require("../operations");
+const testHelpers_1 = require("../../../testHelpers");
 jest.mock("../operations");
 /**
  * in this test case:
@@ -16,18 +17,21 @@ jest.mock("../operations");
  */
 describe("getOwnRealVerifications", () => {
     beforeAll(() => {
-        operations_1.checkOwnVerification.mockImplementation(async ({ signature }) => {
+        jest.fn(() => 1).mockImplementation(() => 123);
+        (0, testHelpers_1.m)(operations_1.checkOwnVerification).mockImplementation(async ({ signature, keyId }) => {
             if (signature === "signatureForLastNameMustermannFromN2")
                 return false;
+            if (keyId === "thisOneIsInvalid")
+                return false;
             return true;
         });
     });
     it("calls the verifyCheck function for each PO, keeping only the valid ones", async () => {
-        const profileObjects = [
+        const profileObjects = (0, testHelpers_1.deepPartial)([
             { n_id: "n1", properties: { fName: "Max", lName: "Mustermann" } },
             { n_id: "n2", properties: { fName: "Erika", lName: "Mustermann" } },
-        ];
-        const verifications = [
+        ]);
+        const verifications = (0, testHelpers_1.deepPartial)([
             {
                 n_id: "nv1",
                 properties: {
@@ -65,6 +69,7 @@ describe("getOwnRealVerifications", () => {
                                 passed: false,
                                 source_n_id: "n2",
                             },
+                            // legacy: key_id is not specified
                         },
                     ],
                 },
@@ -103,14 +108,56 @@ describe("getOwnRealVerifications", () => {
                     ],
                 },
             },
-        ];
+            {
+                n_id: "nv6",
+                properties: {
+                    verifications: [
+                        {
+                            signature: "signatureForFirstNameErika",
+                            data: {
+                                field: "fName",
+                                verifier_source_id: "Ministry of pike river mine re-entry",
+                                verifier_service_id: "Minister for pike river re-entry",
+                                verifier_id: "v1",
+                                verification_date: "2020-08-28T23:11:20.592912",
+                                request_div: "x2",
+                                passed: false,
+                                source_n_id: "n2",
+                            },
+                            key_id: "thisOneIsInvalid", // signature & data is good, but this key will fail
+                        },
+                    ],
+                },
+            },
+            {
+                n_id: "nv7",
+                properties: {
+                    verifications: [
+                        {
+                            signature: "signatureForFirstNameErika",
+                            data: {
+                                field: "fName",
+                                verifier_source_id: "Ministry of pike river mine re-entry",
+                                verifier_service_id: "Minister for pike river re-entry",
+                                verifier_id: "v1",
+                                verification_date: "2020-08-28T23:11:20.592912",
+                                request_div: "x2",
+                                passed: false,
+                                source_n_id: "n2",
+                            },
+                            key_id: "raytio", // everything is valid, this is the right key_id
+                        },
+                    ],
+                },
+            },
+        ]);
         const realVers = await (0, __1.getOwnRealVerifications)({
             profileObjects,
             verifications,
             userId: "geesepolice2002",
         });
-        expect(operations_1.checkOwnVerification).toHaveBeenCalledTimes(3);
-        // 3 times, not 5. Because this new method doesn't need to build a big matrix of possible combinations
+        expect(operations_1.checkOwnVerification).toHaveBeenCalledTimes(5);
+        // 5 times. Because this new method doesn't need to build a big matrix of possible combinations
         expect(realVers).toStrictEqual([
             {
                 fieldName: "fName",
@@ -147,6 +194,24 @@ describe("getOwnRealVerifications", () => {
                 xId: "x2",
             },
             // note how lastName is not included since it's invalid
+            // nv6 is not included because the key is invalid
+            {
+                fieldName: "fName",
+                value: "Erika",
+                belongsToNId: "n2",
+                nID: "nv7",
+                expired: false,
+                metadata: undefined,
+                provider: {
+                    dataSourceNId: "Ministry of pike river mine re-entry",
+                    date: new Date("2020-08-28T23:11:20.592Z"),
+                    serviceProviderNId: "Minister for pike river re-entry",
+                    verifierNId: "v1",
+                },
+                signature: "signatureForFirstNameErika",
+                verified: false,
+                xId: "x2",
+            },
         ]);
     });
 });

package/dist/verifications/verifyCheck/getOwnRealVerifications.js

@@ -17,7 +17,8 @@ const getOwnRealVerifications = async ({ verifications, profileObjects, userId,
     // because attempting hundreds of webcrypto operations simultaneously will
     // probably upset some heritage web browser.
     for (const ver of verifications) {
-        for (const { data, signature } of ver.properties.verifications) {
+        for (const verPO of ver.properties.verifications) {
+            const { data, signature } = verPO;
             const sourcePO = profileObjects.find(PO => PO.n_id === data.source_n_id);
             if (!sourcePO)
                 continue;
@@ -34,6 +35,7 @@ const getOwnRealVerifications = async ({ verifications, profileObjects, userId,
                 userId,
                 value: (0, maybeRereference_1.maybeRereference)(value),
                 signature,
+                keyId: verPO.key_id,
             });
             if (!isGenuine)
                 continue;