@sphereon/ssi-sdk.data-store 0.18.1 → 0.18.2-unstable.10

package/dist/contact/ContactStore.js

@@ -1,366 +1,366 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContactStore = void 0;
-const typeorm_1 = require("typeorm");
-const debug_1 = __importDefault(require("debug"));
-const AbstractContactStore_1 = require("./AbstractContactStore");
-const PartyEntity_1 = require("../entities/contact/PartyEntity");
-const IdentityEntity_1 = require("../entities/contact/IdentityEntity");
-const IdentityMetadataItemEntity_1 = require("../entities/contact/IdentityMetadataItemEntity");
-const CorrelationIdentifierEntity_1 = require("../entities/contact/CorrelationIdentifierEntity");
-const ConnectionEntity_1 = require("../entities/contact/ConnectionEntity");
-const BaseConfigEntity_1 = require("../entities/contact/BaseConfigEntity");
-const PartyRelationshipEntity_1 = require("../entities/contact/PartyRelationshipEntity");
-const PartyTypeEntity_1 = require("../entities/contact/PartyTypeEntity");
-const BaseContactEntity_1 = require("../entities/contact/BaseContactEntity");
-const MappingUtils_1 = require("../utils/contact/MappingUtils");
-const types_1 = require("../types");
-const debug = (0, debug_1.default)('sphereon:ssi-sdk:contact-store');
-class ContactStore extends AbstractContactStore_1.AbstractContactStore {
-    constructor(dbConnection) {
-        super();
-        this.getParty = ({ partyId }) => __awaiter(this, void 0, void 0, function* () {
-            const result = yield (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity).findOne({
-                where: { id: partyId },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No party found for id: ${partyId}`));
-            }
-            return (0, MappingUtils_1.partyFrom)(result);
-        });
-        this.getParties = (args) => __awaiter(this, void 0, void 0, function* () {
-            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
-            const initialResult = yield partyRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
-            const result = yield partyRepository.find({
-                where: {
-                    id: (0, typeorm_1.In)(initialResult.map((party) => party.id)),
-                },
-            });
-            return result.map((party) => (0, MappingUtils_1.partyFrom)(party));
-        });
-        this.addParty = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { identities, contact, partyType } = args;
-            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
-            if (!this.hasCorrectPartyType(partyType.type, contact)) {
-                return Promise.reject(Error(`Party type ${partyType.type}, does not match for provided contact`));
-            }
-            for (const identity of identities !== null && identities !== void 0 ? identities : []) {
-                if (identity.identifier.type === types_1.CorrelationIdentifierEnum.URL) {
-                    if (!identity.connection) {
-                        return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierEnum.URL} should contain a connection`));
-                    }
-                    if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
-                        return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`));
-                    }
-                }
-            }
-            const partyEntity = (0, MappingUtils_1.partyEntityFrom)(args);
-            debug('Adding party', args);
-            const createdResult = yield partyRepository.save(partyEntity);
-            return (0, MappingUtils_1.partyFrom)(createdResult);
-        });
-        this.updateParty = ({ party }) => __awaiter(this, void 0, void 0, function* () {
-            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
-            const result = yield partyRepository.findOne({
-                where: { id: party.id },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No party found for id: ${party.id}`));
-            }
-            const updatedParty = Object.assign(Object.assign({}, party), { identities: result.identities, type: result.partyType, relationships: result.relationships, electronicAddresses: result.electronicAddresses });
-            debug('Updating party', party);
-            const updatedResult = yield partyRepository.save(updatedParty, { transaction: true });
-            return (0, MappingUtils_1.partyFrom)(updatedResult);
-        });
-        this.removeParty = ({ partyId }) => __awaiter(this, void 0, void 0, function* () {
-            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
-            debug('Removing party', partyId);
-            partyRepository
-                .findOneById(partyId)
-                .then((party) => __awaiter(this, void 0, void 0, function* () {
-                if (!party) {
-                    yield Promise.reject(Error(`Unable to find the party with id to remove: ${partyId}`));
-                }
-                else {
-                    yield this.deleteIdentities(party.identities);
-                    yield partyRepository
-                        .delete({ id: partyId })
-                        .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)));
-                    const partyContactRepository = (yield this.dbConnection).getRepository(BaseContactEntity_1.BaseContactEntity);
-                    yield partyContactRepository
-                        .delete({ id: party.contact.id })
-                        .catch((error) => Promise.reject(Error(`Unable to remove party contact with id: ${party.contact.id}. ${error}`)));
-                }
-            }))
-                .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)));
-        });
-        this.getIdentity = ({ identityId }) => __awaiter(this, void 0, void 0, function* () {
-            const result = yield (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity).findOne({
-                where: { id: identityId },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No identity found for id: ${identityId}`));
-            }
-            return (0, MappingUtils_1.identityFrom)(result);
-        });
-        this.getIdentities = (args) => __awaiter(this, void 0, void 0, function* () {
-            const identityRepository = (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity);
-            const initialResult = yield identityRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
-            const result = yield identityRepository.find({
-                where: {
-                    id: (0, typeorm_1.In)(initialResult.map((identity) => identity.id)),
-                },
-            });
-            return result.map((identity) => (0, MappingUtils_1.identityFrom)(identity));
-        });
-        this.addIdentity = ({ identity, partyId }) => __awaiter(this, void 0, void 0, function* () {
-            const party = yield (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity).findOne({
-                where: { id: partyId },
-            });
-            if (!party) {
-                return Promise.reject(Error(`No party found for id: ${partyId}`));
-            }
-            if (identity.identifier.type === types_1.CorrelationIdentifierEnum.URL) {
-                if (!identity.connection) {
-                    return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierEnum.URL} should contain a connection`));
-                }
-                if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
-                    return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`));
-                }
-            }
-            const identityEntity = (0, MappingUtils_1.identityEntityFrom)(identity);
-            identityEntity.party = party;
-            debug('Adding identity', identity);
-            const result = yield (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity).save(identityEntity, {
-                transaction: true,
-            });
-            return (0, MappingUtils_1.identityFrom)(result);
-        });
-        this.updateIdentity = ({ identity }) => __awaiter(this, void 0, void 0, function* () {
-            const identityRepository = (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity);
-            const result = yield identityRepository.findOne({
-                where: { id: identity.id },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No identity found for id: ${identity.id}`));
-            }
-            if (identity.identifier.type === types_1.CorrelationIdentifierEnum.URL) {
-                if (!identity.connection) {
-                    return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierEnum.URL} should contain a connection`));
-                }
-                if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
-                    return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`));
-                }
-            }
-            debug('Updating identity', identity);
-            const updatedResult = yield identityRepository.save(identity, { transaction: true });
-            return (0, MappingUtils_1.identityFrom)(updatedResult);
-        });
-        this.removeIdentity = ({ identityId }) => __awaiter(this, void 0, void 0, function* () {
-            const identity = yield (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity).findOne({
-                where: { id: identityId },
-            });
-            if (!identity) {
-                return Promise.reject(Error(`No identity found for id: ${identityId}`));
-            }
-            debug('Removing identity', identityId);
-            yield this.deleteIdentities([identity]);
-        });
-        this.addRelationship = ({ leftId, rightId }) => __awaiter(this, void 0, void 0, function* () {
-            return this.assertRelationshipSides(leftId, rightId).then(() => __awaiter(this, void 0, void 0, function* () {
-                const relationship = (0, MappingUtils_1.partyRelationshipEntityFrom)({
-                    leftId,
-                    rightId,
-                });
-                debug('Adding party relationship', relationship);
-                const createdResult = yield (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity).save(relationship);
-                return (0, MappingUtils_1.partyRelationshipFrom)(createdResult);
-            }));
-        });
-        this.getRelationship = ({ relationshipId }) => __awaiter(this, void 0, void 0, function* () {
-            const result = yield (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity).findOne({
-                where: { id: relationshipId },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No relationship found for id: ${relationshipId}`));
-            }
-            return (0, MappingUtils_1.partyRelationshipFrom)(result);
-        });
-        this.getRelationships = (args) => __awaiter(this, void 0, void 0, function* () {
-            const partyRelationshipRepository = (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity);
-            const initialResult = yield partyRelationshipRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
-            const result = yield partyRelationshipRepository.find({
-                where: {
-                    id: (0, typeorm_1.In)(initialResult.map((partyRelationship) => partyRelationship.id)),
-                },
-            });
-            return result.map((partyRelationship) => (0, MappingUtils_1.partyRelationshipFrom)(partyRelationship));
-        });
-        this.updateRelationship = ({ relationship }) => __awaiter(this, void 0, void 0, function* () {
-            const partyRelationshipRepository = (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity);
-            const result = yield partyRelationshipRepository.findOne({
-                where: { id: relationship.id },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No party relationship found for id: ${relationship.id}`));
-            }
-            return this.assertRelationshipSides(relationship.leftId, relationship.rightId).then(() => __awaiter(this, void 0, void 0, function* () {
-                debug('Updating party relationship', relationship);
-                const updatedResult = yield partyRelationshipRepository.save(relationship, { transaction: true });
-                return (0, MappingUtils_1.partyRelationshipFrom)(updatedResult);
-            }));
-        });
-        this.removeRelationship = ({ relationshipId }) => __awaiter(this, void 0, void 0, function* () {
-            const partyRelationshipRepository = (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity);
-            const relationship = yield partyRelationshipRepository.findOne({
-                where: { id: relationshipId },
-            });
-            if (!relationship) {
-                return Promise.reject(Error(`No relationship found for id: ${relationshipId}`));
-            }
-            debug('Removing relationship', relationshipId);
-            yield partyRelationshipRepository.delete(relationshipId);
-        });
-        this.addPartyType = (args) => __awaiter(this, void 0, void 0, function* () {
-            const partyEntity = (0, MappingUtils_1.partyTypeEntityFrom)(args);
-            debug('Adding party type', args);
-            const createdResult = yield (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity).save(partyEntity);
-            return (0, MappingUtils_1.partyTypeFrom)(createdResult);
-        });
-        this.getPartyType = ({ partyTypeId }) => __awaiter(this, void 0, void 0, function* () {
-            const result = yield (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity).findOne({
-                where: { id: partyTypeId },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No party type found for id: ${partyTypeId}`));
-            }
-            return (0, MappingUtils_1.partyTypeFrom)(result);
-        });
-        this.getPartyTypes = (args) => __awaiter(this, void 0, void 0, function* () {
-            const partyTypeRepository = (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity);
-            const initialResult = yield partyTypeRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
-            const result = yield partyTypeRepository.find({
-                where: {
-                    id: (0, typeorm_1.In)(initialResult.map((partyType) => partyType.id)),
-                },
-            });
-            return result.map((partyType) => (0, MappingUtils_1.partyTypeFrom)(partyType));
-        });
-        this.updatePartyType = ({ partyType }) => __awaiter(this, void 0, void 0, function* () {
-            const partyTypeRepository = (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity);
-            const result = yield partyTypeRepository.findOne({
-                where: { id: partyType.id },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No party type found for id: ${partyType.id}`));
-            }
-            debug('Updating party type', partyType);
-            const updatedResult = yield partyTypeRepository.save(partyType, { transaction: true });
-            return (0, MappingUtils_1.partyTypeFrom)(updatedResult);
-        });
-        this.removePartyType = ({ partyTypeId }) => __awaiter(this, void 0, void 0, function* () {
-            const parties = yield (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity).find({
-                where: {
-                    partyType: {
-                        id: partyTypeId,
-                    },
-                },
-            });
-            if (parties.length > 0) {
-                return Promise.reject(Error(`Unable to remove party type with id: ${partyTypeId}. Party type is in use`));
-            }
-            const partyTypeRepository = (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity);
-            const partyType = yield partyTypeRepository.findOne({
-                where: { id: partyTypeId },
-            });
-            if (!partyType) {
-                return Promise.reject(Error(`No party type found for id: ${partyTypeId}`));
-            }
-            debug('Removing party type', partyTypeId);
-            yield partyTypeRepository.delete(partyTypeId);
-        });
-        this.dbConnection = dbConnection;
-    }
-    hasCorrectConnectionConfig(type, config) {
-        switch (type) {
-            case types_1.ConnectionTypeEnum.OPENID_CONNECT:
-                return (0, MappingUtils_1.isOpenIdConfig)(config);
-            case types_1.ConnectionTypeEnum.SIOPv2:
-                return (0, MappingUtils_1.isDidAuthConfig)(config);
-            default:
-                throw new Error('Connection type not supported');
-        }
-    }
-    hasCorrectPartyType(type, contact) {
-        switch (type) {
-            case types_1.PartyTypeEnum.NATURAL_PERSON:
-                return (0, MappingUtils_1.isNaturalPerson)(contact);
-            case types_1.PartyTypeEnum.ORGANIZATION:
-                return (0, MappingUtils_1.isOrganization)(contact);
-            default:
-                throw new Error('Party type not supported');
-        }
-    }
-    deleteIdentities(identities) {
-        return __awaiter(this, void 0, void 0, function* () {
-            debug('Removing identities', identities);
-            identities.map((identity) => __awaiter(this, void 0, void 0, function* () {
-                yield (yield this.dbConnection)
-                    .getRepository(CorrelationIdentifierEntity_1.CorrelationIdentifierEntity)
-                    .delete(identity.identifier.id)
-                    .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id: ${identity.identifier.id}. ${error}`)));
-                if (identity.connection) {
-                    yield (yield this.dbConnection).getRepository(BaseConfigEntity_1.BaseConfigEntity).delete(identity.connection.config.id);
-                    yield (yield this.dbConnection)
-                        .getRepository(ConnectionEntity_1.ConnectionEntity)
-                        .delete(identity.connection.id)
-                        .catch((error) => Promise.reject(Error(`Unable to remove identity.connection with id. ${error}`)));
-                }
-                if (identity.metadata) {
-                    identity.metadata.map((metadataItem) => __awaiter(this, void 0, void 0, function* () {
-                        yield (yield this.dbConnection)
-                            .getRepository(IdentityMetadataItemEntity_1.IdentityMetadataItemEntity)
-                            .delete(metadataItem.id)
-                            .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${metadataItem.id}. ${error}`)));
-                    }));
-                }
-                ;
-                (yield this.dbConnection)
-                    .getRepository(IdentityEntity_1.IdentityEntity)
-                    .delete(identity.id)
-                    .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${identity.id}. ${error}`)));
-            }));
-        });
-    }
-    assertRelationshipSides(leftId, rightId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
-            const leftParty = yield partyRepository.findOne({
-                where: { id: leftId },
-            });
-            if (!leftParty) {
-                return Promise.reject(Error(`No party found for left side of the relationship, party id: ${leftId}`));
-            }
-            const rightParty = yield partyRepository.findOne({
-                where: { id: rightId },
-            });
-            if (!rightParty) {
-                return Promise.reject(Error(`No party found for right side of the relationship, party id: ${rightId}`));
-            }
-        });
-    }
-}
-exports.ContactStore = ContactStore;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactStore = void 0;
+const typeorm_1 = require("typeorm");
+const debug_1 = __importDefault(require("debug"));
+const AbstractContactStore_1 = require("./AbstractContactStore");
+const PartyEntity_1 = require("../entities/contact/PartyEntity");
+const IdentityEntity_1 = require("../entities/contact/IdentityEntity");
+const IdentityMetadataItemEntity_1 = require("../entities/contact/IdentityMetadataItemEntity");
+const CorrelationIdentifierEntity_1 = require("../entities/contact/CorrelationIdentifierEntity");
+const ConnectionEntity_1 = require("../entities/contact/ConnectionEntity");
+const BaseConfigEntity_1 = require("../entities/contact/BaseConfigEntity");
+const PartyRelationshipEntity_1 = require("../entities/contact/PartyRelationshipEntity");
+const PartyTypeEntity_1 = require("../entities/contact/PartyTypeEntity");
+const BaseContactEntity_1 = require("../entities/contact/BaseContactEntity");
+const MappingUtils_1 = require("../utils/contact/MappingUtils");
+const types_1 = require("../types");
+const debug = (0, debug_1.default)('sphereon:ssi-sdk:contact-store');
+class ContactStore extends AbstractContactStore_1.AbstractContactStore {
+    constructor(dbConnection) {
+        super();
+        this.getParty = ({ partyId }) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity).findOne({
+                where: { id: partyId },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No party found for id: ${partyId}`));
+            }
+            return (0, MappingUtils_1.partyFrom)(result);
+        });
+        this.getParties = (args) => __awaiter(this, void 0, void 0, function* () {
+            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
+            const initialResult = yield partyRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
+            const result = yield partyRepository.find({
+                where: {
+                    id: (0, typeorm_1.In)(initialResult.map((party) => party.id)),
+                },
+            });
+            return result.map((party) => (0, MappingUtils_1.partyFrom)(party));
+        });
+        this.addParty = (args) => __awaiter(this, void 0, void 0, function* () {
+            const { identities, contact, partyType } = args;
+            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
+            if (!this.hasCorrectPartyType(partyType.type, contact)) {
+                return Promise.reject(Error(`Party type ${partyType.type}, does not match for provided contact`));
+            }
+            for (const identity of identities !== null && identities !== void 0 ? identities : []) {
+                if (identity.identifier.type === types_1.CorrelationIdentifierEnum.URL) {
+                    if (!identity.connection) {
+                        return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierEnum.URL} should contain a connection`));
+                    }
+                    if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
+                        return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`));
+                    }
+                }
+            }
+            const partyEntity = (0, MappingUtils_1.partyEntityFrom)(args);
+            debug('Adding party', args);
+            const createdResult = yield partyRepository.save(partyEntity);
+            return (0, MappingUtils_1.partyFrom)(createdResult);
+        });
+        this.updateParty = ({ party }) => __awaiter(this, void 0, void 0, function* () {
+            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
+            const result = yield partyRepository.findOne({
+                where: { id: party.id },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No party found for id: ${party.id}`));
+            }
+            const updatedParty = Object.assign(Object.assign({}, party), { identities: result.identities, type: result.partyType, relationships: result.relationships, electronicAddresses: result.electronicAddresses });
+            debug('Updating party', party);
+            const updatedResult = yield partyRepository.save(updatedParty, { transaction: true });
+            return (0, MappingUtils_1.partyFrom)(updatedResult);
+        });
+        this.removeParty = ({ partyId }) => __awaiter(this, void 0, void 0, function* () {
+            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
+            debug('Removing party', partyId);
+            partyRepository
+                .findOneById(partyId)
+                .then((party) => __awaiter(this, void 0, void 0, function* () {
+                if (!party) {
+                    yield Promise.reject(Error(`Unable to find the party with id to remove: ${partyId}`));
+                }
+                else {
+                    yield this.deleteIdentities(party.identities);
+                    yield partyRepository
+                        .delete({ id: partyId })
+                        .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)));
+                    const partyContactRepository = (yield this.dbConnection).getRepository(BaseContactEntity_1.BaseContactEntity);
+                    yield partyContactRepository
+                        .delete({ id: party.contact.id })
+                        .catch((error) => Promise.reject(Error(`Unable to remove party contact with id: ${party.contact.id}. ${error}`)));
+                }
+            }))
+                .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)));
+        });
+        this.getIdentity = ({ identityId }) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity).findOne({
+                where: { id: identityId },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No identity found for id: ${identityId}`));
+            }
+            return (0, MappingUtils_1.identityFrom)(result);
+        });
+        this.getIdentities = (args) => __awaiter(this, void 0, void 0, function* () {
+            const identityRepository = (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity);
+            const initialResult = yield identityRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
+            const result = yield identityRepository.find({
+                where: {
+                    id: (0, typeorm_1.In)(initialResult.map((identity) => identity.id)),
+                },
+            });
+            return result.map((identity) => (0, MappingUtils_1.identityFrom)(identity));
+        });
+        this.addIdentity = ({ identity, partyId }) => __awaiter(this, void 0, void 0, function* () {
+            const party = yield (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity).findOne({
+                where: { id: partyId },
+            });
+            if (!party) {
+                return Promise.reject(Error(`No party found for id: ${partyId}`));
+            }
+            if (identity.identifier.type === types_1.CorrelationIdentifierEnum.URL) {
+                if (!identity.connection) {
+                    return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierEnum.URL} should contain a connection`));
+                }
+                if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
+                    return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`));
+                }
+            }
+            const identityEntity = (0, MappingUtils_1.identityEntityFrom)(identity);
+            identityEntity.party = party;
+            debug('Adding identity', identity);
+            const result = yield (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity).save(identityEntity, {
+                transaction: true,
+            });
+            return (0, MappingUtils_1.identityFrom)(result);
+        });
+        this.updateIdentity = ({ identity }) => __awaiter(this, void 0, void 0, function* () {
+            const identityRepository = (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity);
+            const result = yield identityRepository.findOne({
+                where: { id: identity.id },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No identity found for id: ${identity.id}`));
+            }
+            if (identity.identifier.type === types_1.CorrelationIdentifierEnum.URL) {
+                if (!identity.connection) {
+                    return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierEnum.URL} should contain a connection`));
+                }
+                if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
+                    return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`));
+                }
+            }
+            debug('Updating identity', identity);
+            const updatedResult = yield identityRepository.save(identity, { transaction: true });
+            return (0, MappingUtils_1.identityFrom)(updatedResult);
+        });
+        this.removeIdentity = ({ identityId }) => __awaiter(this, void 0, void 0, function* () {
+            const identity = yield (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity).findOne({
+                where: { id: identityId },
+            });
+            if (!identity) {
+                return Promise.reject(Error(`No identity found for id: ${identityId}`));
+            }
+            debug('Removing identity', identityId);
+            yield this.deleteIdentities([identity]);
+        });
+        this.addRelationship = ({ leftId, rightId }) => __awaiter(this, void 0, void 0, function* () {
+            return this.assertRelationshipSides(leftId, rightId).then(() => __awaiter(this, void 0, void 0, function* () {
+                const relationship = (0, MappingUtils_1.partyRelationshipEntityFrom)({
+                    leftId,
+                    rightId,
+                });
+                debug('Adding party relationship', relationship);
+                const createdResult = yield (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity).save(relationship);
+                return (0, MappingUtils_1.partyRelationshipFrom)(createdResult);
+            }));
+        });
+        this.getRelationship = ({ relationshipId }) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity).findOne({
+                where: { id: relationshipId },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No relationship found for id: ${relationshipId}`));
+            }
+            return (0, MappingUtils_1.partyRelationshipFrom)(result);
+        });
+        this.getRelationships = (args) => __awaiter(this, void 0, void 0, function* () {
+            const partyRelationshipRepository = (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity);
+            const initialResult = yield partyRelationshipRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
+            const result = yield partyRelationshipRepository.find({
+                where: {
+                    id: (0, typeorm_1.In)(initialResult.map((partyRelationship) => partyRelationship.id)),
+                },
+            });
+            return result.map((partyRelationship) => (0, MappingUtils_1.partyRelationshipFrom)(partyRelationship));
+        });
+        this.updateRelationship = ({ relationship }) => __awaiter(this, void 0, void 0, function* () {
+            const partyRelationshipRepository = (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity);
+            const result = yield partyRelationshipRepository.findOne({
+                where: { id: relationship.id },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No party relationship found for id: ${relationship.id}`));
+            }
+            return this.assertRelationshipSides(relationship.leftId, relationship.rightId).then(() => __awaiter(this, void 0, void 0, function* () {
+                debug('Updating party relationship', relationship);
+                const updatedResult = yield partyRelationshipRepository.save(relationship, { transaction: true });
+                return (0, MappingUtils_1.partyRelationshipFrom)(updatedResult);
+            }));
+        });
+        this.removeRelationship = ({ relationshipId }) => __awaiter(this, void 0, void 0, function* () {
+            const partyRelationshipRepository = (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity);
+            const relationship = yield partyRelationshipRepository.findOne({
+                where: { id: relationshipId },
+            });
+            if (!relationship) {
+                return Promise.reject(Error(`No relationship found for id: ${relationshipId}`));
+            }
+            debug('Removing relationship', relationshipId);
+            yield partyRelationshipRepository.delete(relationshipId);
+        });
+        this.addPartyType = (args) => __awaiter(this, void 0, void 0, function* () {
+            const partyEntity = (0, MappingUtils_1.partyTypeEntityFrom)(args);
+            debug('Adding party type', args);
+            const createdResult = yield (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity).save(partyEntity);
+            return (0, MappingUtils_1.partyTypeFrom)(createdResult);
+        });
+        this.getPartyType = ({ partyTypeId }) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity).findOne({
+                where: { id: partyTypeId },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No party type found for id: ${partyTypeId}`));
+            }
+            return (0, MappingUtils_1.partyTypeFrom)(result);
+        });
+        this.getPartyTypes = (args) => __awaiter(this, void 0, void 0, function* () {
+            const partyTypeRepository = (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity);
+            const initialResult = yield partyTypeRepository.find(Object.assign({}, ((args === null || args === void 0 ? void 0 : args.filter) && { where: args === null || args === void 0 ? void 0 : args.filter })));
+            const result = yield partyTypeRepository.find({
+                where: {
+                    id: (0, typeorm_1.In)(initialResult.map((partyType) => partyType.id)),
+                },
+            });
+            return result.map((partyType) => (0, MappingUtils_1.partyTypeFrom)(partyType));
+        });
+        this.updatePartyType = ({ partyType }) => __awaiter(this, void 0, void 0, function* () {
+            const partyTypeRepository = (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity);
+            const result = yield partyTypeRepository.findOne({
+                where: { id: partyType.id },
+            });
+            if (!result) {
+                return Promise.reject(Error(`No party type found for id: ${partyType.id}`));
+            }
+            debug('Updating party type', partyType);
+            const updatedResult = yield partyTypeRepository.save(partyType, { transaction: true });
+            return (0, MappingUtils_1.partyTypeFrom)(updatedResult);
+        });
+        this.removePartyType = ({ partyTypeId }) => __awaiter(this, void 0, void 0, function* () {
+            const parties = yield (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity).find({
+                where: {
+                    partyType: {
+                        id: partyTypeId,
+                    },
+                },
+            });
+            if (parties.length > 0) {
+                return Promise.reject(Error(`Unable to remove party type with id: ${partyTypeId}. Party type is in use`));
+            }
+            const partyTypeRepository = (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity);
+            const partyType = yield partyTypeRepository.findOne({
+                where: { id: partyTypeId },
+            });
+            if (!partyType) {
+                return Promise.reject(Error(`No party type found for id: ${partyTypeId}`));
+            }
+            debug('Removing party type', partyTypeId);
+            yield partyTypeRepository.delete(partyTypeId);
+        });
+        this.dbConnection = dbConnection;
+    }
+    hasCorrectConnectionConfig(type, config) {
+        switch (type) {
+            case types_1.ConnectionTypeEnum.OPENID_CONNECT:
+                return (0, MappingUtils_1.isOpenIdConfig)(config);
+            case types_1.ConnectionTypeEnum.SIOPv2:
+                return (0, MappingUtils_1.isDidAuthConfig)(config);
+            default:
+                throw new Error('Connection type not supported');
+        }
+    }
+    hasCorrectPartyType(type, contact) {
+        switch (type) {
+            case types_1.PartyTypeEnum.NATURAL_PERSON:
+                return (0, MappingUtils_1.isNaturalPerson)(contact);
+            case types_1.PartyTypeEnum.ORGANIZATION:
+                return (0, MappingUtils_1.isOrganization)(contact);
+            default:
+                throw new Error('Party type not supported');
+        }
+    }
+    deleteIdentities(identities) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('Removing identities', identities);
+            identities.map((identity) => __awaiter(this, void 0, void 0, function* () {
+                yield (yield this.dbConnection)
+                    .getRepository(CorrelationIdentifierEntity_1.CorrelationIdentifierEntity)
+                    .delete(identity.identifier.id)
+                    .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id: ${identity.identifier.id}. ${error}`)));
+                if (identity.connection) {
+                    yield (yield this.dbConnection).getRepository(BaseConfigEntity_1.BaseConfigEntity).delete(identity.connection.config.id);
+                    yield (yield this.dbConnection)
+                        .getRepository(ConnectionEntity_1.ConnectionEntity)
+                        .delete(identity.connection.id)
+                        .catch((error) => Promise.reject(Error(`Unable to remove identity.connection with id. ${error}`)));
+                }
+                if (identity.metadata) {
+                    identity.metadata.map((metadataItem) => __awaiter(this, void 0, void 0, function* () {
+                        yield (yield this.dbConnection)
+                            .getRepository(IdentityMetadataItemEntity_1.IdentityMetadataItemEntity)
+                            .delete(metadataItem.id)
+                            .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${metadataItem.id}. ${error}`)));
+                    }));
+                }
+                ;
+                (yield this.dbConnection)
+                    .getRepository(IdentityEntity_1.IdentityEntity)
+                    .delete(identity.id)
+                    .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${identity.id}. ${error}`)));
+            }));
+        });
+    }
+    assertRelationshipSides(leftId, rightId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
+            const leftParty = yield partyRepository.findOne({
+                where: { id: leftId },
+            });
+            if (!leftParty) {
+                return Promise.reject(Error(`No party found for left side of the relationship, party id: ${leftId}`));
+            }
+            const rightParty = yield partyRepository.findOne({
+                where: { id: rightId },
+            });
+            if (!rightParty) {
+                return Promise.reject(Error(`No party found for right side of the relationship, party id: ${rightId}`));
+            }
+        });
+    }
+}
+exports.ContactStore = ContactStore;
 //# sourceMappingURL=ContactStore.js.map