@sphereon/ssi-sdk.data-store 0.33.0 → 0.33.1-feature.vcdm2.4

package/dist/contact/ContactStore.js

@@ -1,573 +1,572 @@
-"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 ElectronicAddressEntity_1 = require("../entities/contact/ElectronicAddressEntity");
-const PhysicalAddressEntity_1 = require("../entities/contact/PhysicalAddressEntity");
-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 {
+import { In } from 'typeorm';
+import Debug from 'debug';
+import { AbstractContactStore } from './AbstractContactStore';
+import { PartyEntity } from '../entities/contact/PartyEntity';
+import { IdentityEntity } from '../entities/contact/IdentityEntity';
+import { IdentityMetadataItemEntity } from '../entities/contact/IdentityMetadataItemEntity';
+import { CorrelationIdentifierEntity } from '../entities/contact/CorrelationIdentifierEntity';
+import { ConnectionEntity } from '../entities/contact/ConnectionEntity';
+import { BaseConfigEntity } from '../entities/contact/BaseConfigEntity';
+import { PartyRelationshipEntity } from '../entities/contact/PartyRelationshipEntity';
+import { PartyTypeEntity } from '../entities/contact/PartyTypeEntity';
+import { BaseContactEntity } from '../entities/contact/BaseContactEntity';
+import { ElectronicAddressEntity } from '../entities/contact/ElectronicAddressEntity';
+import { PhysicalAddressEntity } from '../entities/contact/PhysicalAddressEntity';
+import { electronicAddressEntityFrom, electronicAddressFrom, identityEntityFrom, identityFrom, isDidAuthConfig, isNaturalPerson, isOpenIdConfig, isOrganization, partyEntityFrom, partyFrom, partyRelationshipEntityFrom, partyRelationshipFrom, partyTypeEntityFrom, partyTypeFrom, physicalAddressEntityFrom, physicalAddressFrom, } from '../utils/contact/MappingUtils';
+import { ConnectionType, CorrelationIdentifierType, PartyTypeType, } from '../types';
+const debug = Debug('sphereon:ssi-sdk:contact-store');
+export class ContactStore extends AbstractContactStore {
+    dbConnection;
     constructor(dbConnection) {
         super();
-        this.getParty = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { partyId } = args;
-            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* () {
-            debug('getParties()', args);
-            const { filter } = args !== null && args !== void 0 ? args : {};
-            const partyRepository = (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity);
-            const filterConditions = this.buildFilters(filter);
-            const initialResult = yield partyRepository.find({ select: ['id'], where: filterConditions });
-            // Fetch the complete entities based on the initial result IDs
-            const result = yield partyRepository.find({ where: { id: (0, typeorm_1.In)(initialResult.map((party) => party.id)) } });
-            debug(`getParties() resulted in ${result.length} parties`);
-            return result.map(MappingUtils_1.partyFrom);
-        });
-        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.CorrelationIdentifierType.URL) {
-                    if (!identity.connection) {
-                        return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierType.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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { party } = args;
-            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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { partyId } = args;
-            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 this.deleteElectronicAddresses(party.electronicAddresses);
-                    yield this.deletePhysicalAddresses(party.physicalAddresses);
-                    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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { identityId } = args;
-            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 { filter } = args !== null && args !== void 0 ? args : {};
-            const identityRepository = (yield this.dbConnection).getRepository(IdentityEntity_1.IdentityEntity);
-            const filterConditions = this.buildFilters(filter);
-            const initialResult = yield identityRepository.find({ select: ['id'], where: filterConditions });
-            const result = yield identityRepository.find({ where: { id: (0, typeorm_1.In)(initialResult.map((identity) => identity.id)) } });
-            return result.map(MappingUtils_1.identityFrom);
-        });
-        this.addIdentity = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { identity, partyId } = args;
-            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.CorrelationIdentifierType.URL) {
-                if (!identity.connection) {
-                    return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierType.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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { identity } = args;
-            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.CorrelationIdentifierType.URL) {
+        this.dbConnection = dbConnection;
+    }
+    getParty = async (args) => {
+        const { partyId } = args;
+        const result = await (await this.dbConnection).getRepository(PartyEntity).findOne({
+            where: { id: partyId },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No party found for id: ${partyId}`));
+        }
+        return partyFrom(result);
+    };
+    getParties = async (args) => {
+        debug('getParties()', args);
+        const { filter } = args ?? {};
+        const partyRepository = (await this.dbConnection).getRepository(PartyEntity);
+        const filterConditions = this.buildFilters(filter);
+        const initialResult = await partyRepository.find({ select: ['id'], where: filterConditions });
+        // Fetch the complete entities based on the initial result IDs
+        const result = await partyRepository.find({ where: { id: In(initialResult.map((party) => party.id)) } });
+        debug(`getParties() resulted in ${result.length} parties`);
+        return result.map(partyFrom);
+    };
+    addParty = async (args) => {
+        const { identities, contact, partyType } = args;
+        const partyRepository = (await this.dbConnection).getRepository(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 ?? []) {
+            if (identity.identifier.type === CorrelationIdentifierType.URL) {
                 if (!identity.connection) {
-                    return Promise.reject(Error(`Identity with correlation type ${types_1.CorrelationIdentifierType.URL} should contain a connection`));
+                    return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierType.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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { identityId } = args;
-            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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { leftId, rightId } = args;
-            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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { relationshipId } = args;
-            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 { filter } = args !== null && args !== void 0 ? args : {};
-            const partyRelationshipRepository = (yield this.dbConnection).getRepository(PartyRelationshipEntity_1.PartyRelationshipEntity);
-            const initialResult = yield partyRelationshipRepository.find(Object.assign({}, (filter && { where: 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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { relationship } = args;
-            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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { relationshipId } = args;
-            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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { partyTypeId } = args;
-            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 { filter } = args !== null && args !== void 0 ? args : {};
-            const partyTypeRepository = (yield this.dbConnection).getRepository(PartyTypeEntity_1.PartyTypeEntity);
-            const initialResult = yield partyTypeRepository.find(Object.assign({}, (filter && { where: 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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { partyType } = args;
-            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 = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { partyTypeId } = args;
-            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.getElectronicAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { electronicAddressId } = args;
-            const result = yield (yield this.dbConnection).getRepository(ElectronicAddressEntity_1.ElectronicAddressEntity).findOne({
-                where: { id: electronicAddressId },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No electronic address found for id: ${electronicAddressId}`));
-            }
-            return (0, MappingUtils_1.electronicAddressFrom)(result);
-        });
-        this.getElectronicAddresses = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { filter } = args !== null && args !== void 0 ? args : {};
-            const electronicAddressRepository = (yield this.dbConnection).getRepository(ElectronicAddressEntity_1.ElectronicAddressEntity);
-            const initialResult = yield electronicAddressRepository.find(Object.assign({}, (filter && { where: filter })));
-            const result = yield electronicAddressRepository.find({
-                where: {
-                    id: (0, typeorm_1.In)(initialResult.map((electronicAddress) => electronicAddress.id)),
-                },
-            });
-            return result.map((electronicAddress) => (0, MappingUtils_1.electronicAddressFrom)(electronicAddress));
-        });
-        this.addElectronicAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { electronicAddress, partyId } = args;
-            const party = yield (yield this.dbConnection).getRepository(PartyEntity_1.PartyEntity).findOne({
-                where: { id: partyId },
-            });
+        }
+        const partyEntity = partyEntityFrom(args);
+        debug('Adding party', args);
+        const createdResult = await partyRepository.save(partyEntity);
+        return partyFrom(createdResult);
+    };
+    updateParty = async (args) => {
+        const { party } = args;
+        const partyRepository = (await this.dbConnection).getRepository(PartyEntity);
+        const result = await partyRepository.findOne({
+            where: { id: party.id },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No party found for id: ${party.id}`));
+        }
+        const updatedParty = {
+            ...party,
+            identities: result.identities,
+            type: result.partyType,
+            relationships: result.relationships,
+            electronicAddresses: result.electronicAddresses,
+        };
+        debug('Updating party', party);
+        const updatedResult = await partyRepository.save(updatedParty, { transaction: true });
+        return partyFrom(updatedResult);
+    };
+    removeParty = async (args) => {
+        const { partyId } = args;
+        const partyRepository = (await this.dbConnection).getRepository(PartyEntity);
+        debug('Removing party', partyId);
+        partyRepository
+            .findOneById(partyId)
+            .then(async (party) => {
             if (!party) {
-                return Promise.reject(Error(`No party found for id: ${partyId}`));
+                await Promise.reject(Error(`Unable to find the party with id to remove: ${partyId}`));
             }
-            const electronicAddressEntity = (0, MappingUtils_1.electronicAddressEntityFrom)(electronicAddress);
-            electronicAddressEntity.party = party;
-            debug('Adding electronic address', electronicAddress);
-            const result = yield (yield this.dbConnection).getRepository(ElectronicAddressEntity_1.ElectronicAddressEntity).save(electronicAddressEntity, {
-                transaction: true,
-            });
-            return (0, MappingUtils_1.electronicAddressFrom)(result);
-        });
-        this.updateElectronicAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { electronicAddress } = args;
-            const electronicAddressRepository = (yield this.dbConnection).getRepository(ElectronicAddressEntity_1.ElectronicAddressEntity);
-            const result = yield electronicAddressRepository.findOne({
-                where: { id: electronicAddress.id },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No electronic address found for id: ${electronicAddress.id}`));
+            else {
+                await this.deleteIdentities(party.identities);
+                await this.deleteElectronicAddresses(party.electronicAddresses);
+                await this.deletePhysicalAddresses(party.physicalAddresses);
+                await partyRepository
+                    .delete({ id: partyId })
+                    .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)));
+                const partyContactRepository = (await this.dbConnection).getRepository(BaseContactEntity);
+                await partyContactRepository
+                    .delete({ id: party.contact.id })
+                    .catch((error) => Promise.reject(Error(`Unable to remove party contact with id: ${party.contact.id}. ${error}`)));
             }
-            debug('Updating electronic address', electronicAddress);
-            const updatedResult = yield electronicAddressRepository.save(electronicAddress, { transaction: true });
-            return (0, MappingUtils_1.electronicAddressFrom)(updatedResult);
-        });
-        this.removeElectronicAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { electronicAddressId } = args;
-            const electronicAddressRepository = (yield this.dbConnection).getRepository(ElectronicAddressEntity_1.ElectronicAddressEntity);
-            const electronicAddress = yield electronicAddressRepository.findOne({
-                where: { id: electronicAddressId },
-            });
-            if (!electronicAddress) {
-                return Promise.reject(Error(`No electronic address found for id: ${electronicAddressId}`));
+        })
+            .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)));
+    };
+    getIdentity = async (args) => {
+        const { identityId } = args;
+        const result = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+            where: { id: identityId },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No identity found for id: ${identityId}`));
+        }
+        return identityFrom(result);
+    };
+    getIdentities = async (args) => {
+        const { filter } = args ?? {};
+        const identityRepository = (await this.dbConnection).getRepository(IdentityEntity);
+        const filterConditions = this.buildFilters(filter);
+        const initialResult = await identityRepository.find({ select: ['id'], where: filterConditions });
+        const result = await identityRepository.find({ where: { id: In(initialResult.map((identity) => identity.id)) } });
+        return result.map(identityFrom);
+    };
+    addIdentity = async (args) => {
+        const { identity, partyId } = args;
+        const party = await (await this.dbConnection).getRepository(PartyEntity).findOne({
+            where: { id: partyId },
+        });
+        if (!party) {
+            return Promise.reject(Error(`No party found for id: ${partyId}`));
+        }
+        if (identity.identifier.type === CorrelationIdentifierType.URL) {
+            if (!identity.connection) {
+                return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierType.URL} should contain a connection`));
             }
-            debug('Removing electronic address', electronicAddressId);
-            yield electronicAddressRepository.delete(electronicAddressId);
-        });
-        this.getPhysicalAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { physicalAddressId } = args;
-            const result = yield (yield this.dbConnection).getRepository(PhysicalAddressEntity_1.PhysicalAddressEntity).findOne({
-                where: { id: physicalAddressId },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No physical address found for id: ${physicalAddressId}`));
+            if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
+                return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`));
             }
-            return (0, MappingUtils_1.physicalAddressFrom)(result);
-        });
-        this.getPhysicalAddresses = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { filter } = args !== null && args !== void 0 ? args : {};
-            const physicalAddressRepository = (yield this.dbConnection).getRepository(PhysicalAddressEntity_1.PhysicalAddressEntity);
-            const initialResult = yield physicalAddressRepository.find(Object.assign({}, (filter && { where: filter })));
-            const result = yield physicalAddressRepository.find({
-                where: {
-                    id: (0, typeorm_1.In)(initialResult.map((physicalAddress) => physicalAddress.id)),
-                },
-            });
-            return result.map((physicalAddress) => (0, MappingUtils_1.physicalAddressFrom)(physicalAddress));
-        });
-        this.addPhysicalAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { physicalAddress, partyId } = args;
-            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}`));
+        }
+        const identityEntity = identityEntityFrom(identity);
+        identityEntity.party = party;
+        debug('Adding identity', identity);
+        const result = await (await this.dbConnection).getRepository(IdentityEntity).save(identityEntity, {
+            transaction: true,
+        });
+        return identityFrom(result);
+    };
+    updateIdentity = async (args) => {
+        const { identity } = args;
+        const identityRepository = (await this.dbConnection).getRepository(IdentityEntity);
+        const result = await identityRepository.findOne({
+            where: { id: identity.id },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No identity found for id: ${identity.id}`));
+        }
+        if (identity.identifier.type === CorrelationIdentifierType.URL) {
+            if (!identity.connection) {
+                return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierType.URL} should contain a connection`));
             }
-            const physicalAddressEntity = (0, MappingUtils_1.physicalAddressEntityFrom)(physicalAddress);
-            physicalAddressEntity.party = party;
-            debug('Adding physical address', physicalAddress);
-            const result = yield (yield this.dbConnection).getRepository(PhysicalAddressEntity_1.PhysicalAddressEntity).save(physicalAddressEntity, {
-                transaction: true,
-            });
-            return (0, MappingUtils_1.physicalAddressFrom)(result);
-        });
-        this.updatePhysicalAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { physicalAddress } = args;
-            const physicalAddressRepository = (yield this.dbConnection).getRepository(PhysicalAddressEntity_1.PhysicalAddressEntity);
-            const result = yield physicalAddressRepository.findOne({
-                where: { id: physicalAddress.id },
-            });
-            if (!result) {
-                return Promise.reject(Error(`No physical address found for id: ${physicalAddress.id}`));
+            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 physical address', physicalAddress);
-            const updatedResult = yield physicalAddressRepository.save(physicalAddress, { transaction: true });
-            return (0, MappingUtils_1.physicalAddressFrom)(updatedResult);
-        });
-        this.removePhysicalAddress = (args) => __awaiter(this, void 0, void 0, function* () {
-            const { physicalAddressId } = args;
-            const physicalAddressRepository = (yield this.dbConnection).getRepository(PhysicalAddressEntity_1.PhysicalAddressEntity);
-            const physicalAddress = yield physicalAddressRepository.findOne({
-                where: { id: physicalAddressId },
+        }
+        debug('Updating identity', identity);
+        const updatedResult = await identityRepository.save(identity, { transaction: true });
+        return identityFrom(updatedResult);
+    };
+    removeIdentity = async (args) => {
+        const { identityId } = args;
+        const identity = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+            where: { id: identityId },
+        });
+        if (!identity) {
+            return Promise.reject(Error(`No identity found for id: ${identityId}`));
+        }
+        debug('Removing identity', identityId);
+        await this.deleteIdentities([identity]);
+    };
+    addRelationship = async (args) => {
+        const { leftId, rightId } = args;
+        return this.assertRelationshipSides(leftId, rightId).then(async () => {
+            const relationship = partyRelationshipEntityFrom({
+                leftId,
+                rightId,
             });
-            if (!physicalAddress) {
-                return Promise.reject(Error(`No physical address found for id: ${physicalAddressId}`));
+            debug('Adding party relationship', relationship);
+            const createdResult = await (await this.dbConnection).getRepository(PartyRelationshipEntity).save(relationship);
+            return partyRelationshipFrom(createdResult);
+        });
+    };
+    getRelationship = async (args) => {
+        const { relationshipId } = args;
+        const result = await (await this.dbConnection).getRepository(PartyRelationshipEntity).findOne({
+            where: { id: relationshipId },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No relationship found for id: ${relationshipId}`));
+        }
+        return partyRelationshipFrom(result);
+    };
+    getRelationships = async (args) => {
+        const { filter } = args ?? {};
+        const partyRelationshipRepository = (await this.dbConnection).getRepository(PartyRelationshipEntity);
+        const initialResult = await partyRelationshipRepository.find({
+            ...(filter && { where: filter }),
+        });
+        const result = await partyRelationshipRepository.find({
+            where: {
+                id: In(initialResult.map((partyRelationship) => partyRelationship.id)),
+            },
+        });
+        return result.map((partyRelationship) => partyRelationshipFrom(partyRelationship));
+    };
+    updateRelationship = async (args) => {
+        const { relationship } = args;
+        const partyRelationshipRepository = (await this.dbConnection).getRepository(PartyRelationshipEntity);
+        const result = await 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(async () => {
+            debug('Updating party relationship', relationship);
+            const updatedResult = await partyRelationshipRepository.save(relationship, { transaction: true });
+            return partyRelationshipFrom(updatedResult);
+        });
+    };
+    removeRelationship = async (args) => {
+        const { relationshipId } = args;
+        const partyRelationshipRepository = (await this.dbConnection).getRepository(PartyRelationshipEntity);
+        const relationship = await partyRelationshipRepository.findOne({
+            where: { id: relationshipId },
+        });
+        if (!relationship) {
+            return Promise.reject(Error(`No relationship found for id: ${relationshipId}`));
+        }
+        debug('Removing relationship', relationshipId);
+        await partyRelationshipRepository.delete(relationshipId);
+    };
+    addPartyType = async (args) => {
+        const partyEntity = partyTypeEntityFrom(args);
+        debug('Adding party type', args);
+        const createdResult = await (await this.dbConnection).getRepository(PartyTypeEntity).save(partyEntity);
+        return partyTypeFrom(createdResult);
+    };
+    getPartyType = async (args) => {
+        const { partyTypeId } = args;
+        const result = await (await this.dbConnection).getRepository(PartyTypeEntity).findOne({
+            where: { id: partyTypeId },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No party type found for id: ${partyTypeId}`));
+        }
+        return partyTypeFrom(result);
+    };
+    getPartyTypes = async (args) => {
+        const { filter } = args ?? {};
+        const partyTypeRepository = (await this.dbConnection).getRepository(PartyTypeEntity);
+        const initialResult = await partyTypeRepository.find({
+            ...(filter && { where: filter }),
+        });
+        const result = await partyTypeRepository.find({
+            where: {
+                id: In(initialResult.map((partyType) => partyType.id)),
+            },
+        });
+        return result.map((partyType) => partyTypeFrom(partyType));
+    };
+    updatePartyType = async (args) => {
+        const { partyType } = args;
+        const partyTypeRepository = (await this.dbConnection).getRepository(PartyTypeEntity);
+        const result = await 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 = await partyTypeRepository.save(partyType, { transaction: true });
+        return partyTypeFrom(updatedResult);
+    };
+    removePartyType = async (args) => {
+        const { partyTypeId } = args;
+        const parties = await (await this.dbConnection).getRepository(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 = (await this.dbConnection).getRepository(PartyTypeEntity);
+        const partyType = await partyTypeRepository.findOne({
+            where: { id: partyTypeId },
+        });
+        if (!partyType) {
+            return Promise.reject(Error(`No party type found for id: ${partyTypeId}`));
+        }
+        debug('Removing party type', partyTypeId);
+        await partyTypeRepository.delete(partyTypeId);
+    };
+    getElectronicAddress = async (args) => {
+        const { electronicAddressId } = args;
+        const result = await (await this.dbConnection).getRepository(ElectronicAddressEntity).findOne({
+            where: { id: electronicAddressId },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No electronic address found for id: ${electronicAddressId}`));
+        }
+        return electronicAddressFrom(result);
+    };
+    getElectronicAddresses = async (args) => {
+        const { filter } = args ?? {};
+        const electronicAddressRepository = (await this.dbConnection).getRepository(ElectronicAddressEntity);
+        const initialResult = await electronicAddressRepository.find({
+            ...(filter && { where: filter }),
+        });
+        const result = await electronicAddressRepository.find({
+            where: {
+                id: In(initialResult.map((electronicAddress) => electronicAddress.id)),
+            },
+        });
+        return result.map((electronicAddress) => electronicAddressFrom(electronicAddress));
+    };
+    addElectronicAddress = async (args) => {
+        const { electronicAddress, partyId } = args;
+        const party = await (await this.dbConnection).getRepository(PartyEntity).findOne({
+            where: { id: partyId },
+        });
+        if (!party) {
+            return Promise.reject(Error(`No party found for id: ${partyId}`));
+        }
+        const electronicAddressEntity = electronicAddressEntityFrom(electronicAddress);
+        electronicAddressEntity.party = party;
+        debug('Adding electronic address', electronicAddress);
+        const result = await (await this.dbConnection).getRepository(ElectronicAddressEntity).save(electronicAddressEntity, {
+            transaction: true,
+        });
+        return electronicAddressFrom(result);
+    };
+    updateElectronicAddress = async (args) => {
+        const { electronicAddress } = args;
+        const electronicAddressRepository = (await this.dbConnection).getRepository(ElectronicAddressEntity);
+        const result = await electronicAddressRepository.findOne({
+            where: { id: electronicAddress.id },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No electronic address found for id: ${electronicAddress.id}`));
+        }
+        debug('Updating electronic address', electronicAddress);
+        const updatedResult = await electronicAddressRepository.save(electronicAddress, { transaction: true });
+        return electronicAddressFrom(updatedResult);
+    };
+    removeElectronicAddress = async (args) => {
+        const { electronicAddressId } = args;
+        const electronicAddressRepository = (await this.dbConnection).getRepository(ElectronicAddressEntity);
+        const electronicAddress = await electronicAddressRepository.findOne({
+            where: { id: electronicAddressId },
+        });
+        if (!electronicAddress) {
+            return Promise.reject(Error(`No electronic address found for id: ${electronicAddressId}`));
+        }
+        debug('Removing electronic address', electronicAddressId);
+        await electronicAddressRepository.delete(electronicAddressId);
+    };
+    getPhysicalAddress = async (args) => {
+        const { physicalAddressId } = args;
+        const result = await (await this.dbConnection).getRepository(PhysicalAddressEntity).findOne({
+            where: { id: physicalAddressId },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No physical address found for id: ${physicalAddressId}`));
+        }
+        return physicalAddressFrom(result);
+    };
+    getPhysicalAddresses = async (args) => {
+        const { filter } = args ?? {};
+        const physicalAddressRepository = (await this.dbConnection).getRepository(PhysicalAddressEntity);
+        const initialResult = await physicalAddressRepository.find({
+            ...(filter && { where: filter }),
+        });
+        const result = await physicalAddressRepository.find({
+            where: {
+                id: In(initialResult.map((physicalAddress) => physicalAddress.id)),
+            },
+        });
+        return result.map((physicalAddress) => physicalAddressFrom(physicalAddress));
+    };
+    addPhysicalAddress = async (args) => {
+        const { physicalAddress, partyId } = args;
+        const party = await (await this.dbConnection).getRepository(PartyEntity).findOne({
+            where: { id: partyId },
+        });
+        if (!party) {
+            return Promise.reject(Error(`No party found for id: ${partyId}`));
+        }
+        const physicalAddressEntity = physicalAddressEntityFrom(physicalAddress);
+        physicalAddressEntity.party = party;
+        debug('Adding physical address', physicalAddress);
+        const result = await (await this.dbConnection).getRepository(PhysicalAddressEntity).save(physicalAddressEntity, {
+            transaction: true,
+        });
+        return physicalAddressFrom(result);
+    };
+    updatePhysicalAddress = async (args) => {
+        const { physicalAddress } = args;
+        const physicalAddressRepository = (await this.dbConnection).getRepository(PhysicalAddressEntity);
+        const result = await physicalAddressRepository.findOne({
+            where: { id: physicalAddress.id },
+        });
+        if (!result) {
+            return Promise.reject(Error(`No physical address found for id: ${physicalAddress.id}`));
+        }
+        debug('Updating physical address', physicalAddress);
+        const updatedResult = await physicalAddressRepository.save(physicalAddress, { transaction: true });
+        return physicalAddressFrom(updatedResult);
+    };
+    removePhysicalAddress = async (args) => {
+        const { physicalAddressId } = args;
+        const physicalAddressRepository = (await this.dbConnection).getRepository(PhysicalAddressEntity);
+        const physicalAddress = await physicalAddressRepository.findOne({
+            where: { id: physicalAddressId },
+        });
+        if (!physicalAddress) {
+            return Promise.reject(Error(`No physical address found for id: ${physicalAddressId}`));
+        }
+        debug('Removing physical address', physicalAddressId);
+        await physicalAddressRepository.delete(physicalAddressId);
+    };
+    hasCorrectConnectionConfig = (type, config) => {
+        switch (type) {
+            case ConnectionType.OPENID_CONNECT:
+                return isOpenIdConfig(config);
+            case ConnectionType.SIOPv2:
+                return isDidAuthConfig(config);
+            default:
+                throw new Error('Connection type not supported');
+        }
+    };
+    hasCorrectPartyType = (type, contact) => {
+        switch (type) {
+            case PartyTypeType.NATURAL_PERSON:
+                return isNaturalPerson(contact);
+            case PartyTypeType.ORGANIZATION:
+                return isOrganization(contact);
+            default:
+                throw new Error('Party type not supported');
+        }
+    };
+    deleteIdentities = async (identities) => {
+        debug('Removing identities', identities);
+        const connection = await this.dbConnection;
+        const correlationIdentifierRepository = connection.getRepository(CorrelationIdentifierEntity);
+        const baseConfigRepository = connection.getRepository(BaseConfigEntity);
+        const connectionRepository = connection.getRepository(ConnectionEntity);
+        const identityMetadataItemRepository = connection.getRepository(IdentityMetadataItemEntity);
+        const identityRepository = connection.getRepository(IdentityEntity);
+        identities.map(async (identity) => {
+            await correlationIdentifierRepository
+                .delete(identity.identifier.id)
+                .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id ${identity.identifier.id}. ${error}`)));
+            if (identity.connection) {
+                await baseConfigRepository.delete(identity.connection.config.id);
+                await connectionRepository
+                    .delete(identity.connection.id)
+                    .catch((error) => Promise.reject(Error(`Unable to remove identity.connection with id ${identity.connection?.id}. ${error}`)));
             }
-            debug('Removing physical address', physicalAddressId);
-            yield physicalAddressRepository.delete(physicalAddressId);
-        });
-        this.hasCorrectConnectionConfig = (type, config) => {
-            switch (type) {
-                case types_1.ConnectionType.OPENID_CONNECT:
-                    return (0, MappingUtils_1.isOpenIdConfig)(config);
-                case types_1.ConnectionType.SIOPv2:
-                    return (0, MappingUtils_1.isDidAuthConfig)(config);
-                default:
-                    throw new Error('Connection type not supported');
+            if (identity.metadata) {
+                identity.metadata.map(async (metadataItem) => {
+                    await identityMetadataItemRepository
+                        .delete(metadataItem.id)
+                        .catch((error) => Promise.reject(Error(`Unable to remove identity.metadataItem with id ${metadataItem.id}. ${error}`)));
+                });
             }
-        };
-        this.hasCorrectPartyType = (type, contact) => {
-            switch (type) {
-                case types_1.PartyTypeType.NATURAL_PERSON:
-                    return (0, MappingUtils_1.isNaturalPerson)(contact);
-                case types_1.PartyTypeType.ORGANIZATION:
-                    return (0, MappingUtils_1.isOrganization)(contact);
-                default:
-                    throw new Error('Party type not supported');
+            await identityRepository
+                .delete(identity.id)
+                .catch((error) => Promise.reject(Error(`Unable to remove identity with id ${identity.id}. ${error}`)));
+        });
+    };
+    deleteElectronicAddresses = async (electronicAddresses) => {
+        debug('Removing electronic addresses', electronicAddresses);
+        const electronicAddressRepository = (await this.dbConnection).getRepository(ElectronicAddressEntity);
+        electronicAddresses.map(async (electronicAddress) => {
+            await electronicAddressRepository
+                .delete(electronicAddress.id)
+                .catch((error) => Promise.reject(Error(`Unable to remove electronic address with id ${electronicAddress.id}. ${error}`)));
+        });
+    };
+    deletePhysicalAddresses = async (physicalAddresses) => {
+        debug('Removing physical addresses', physicalAddresses);
+        const physicalAddressRepository = (await this.dbConnection).getRepository(PhysicalAddressEntity);
+        physicalAddresses.map(async (physicalAddress) => {
+            await physicalAddressRepository
+                .delete(physicalAddress.id)
+                .catch((error) => Promise.reject(Error(`Unable to remove physical address with id ${physicalAddress.id}. ${error}`)));
+        });
+    };
+    assertRelationshipSides = async (leftId, rightId) => {
+        const partyRepository = (await this.dbConnection).getRepository(PartyEntity);
+        const leftParty = await 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 = await partyRepository.findOne({
+            where: { id: rightId },
+        });
+        if (!rightParty) {
+            return Promise.reject(Error(`No party found for right side of the relationship, party id: ${rightId}`));
+        }
+    };
+    buildFilters = (filter) => {
+        if (!filter)
+            return {};
+        return filter.map((condition) => this.processCondition(condition));
+    };
+    processCondition = (condition) => {
+        const conditionObject = {};
+        Object.keys(condition).forEach((key) => {
+            const value = condition[key];
+            if (key === 'metadata' && value) {
+                conditionObject[key] = this.buildMetadataCondition(value);
             }
-        };
-        this.deleteIdentities = (identities) => __awaiter(this, void 0, void 0, function* () {
-            debug('Removing identities', identities);
-            const connection = yield this.dbConnection;
-            const correlationIdentifierRepository = connection.getRepository(CorrelationIdentifierEntity_1.CorrelationIdentifierEntity);
-            const baseConfigRepository = connection.getRepository(BaseConfigEntity_1.BaseConfigEntity);
-            const connectionRepository = connection.getRepository(ConnectionEntity_1.ConnectionEntity);
-            const identityMetadataItemRepository = connection.getRepository(IdentityMetadataItemEntity_1.IdentityMetadataItemEntity);
-            const identityRepository = connection.getRepository(IdentityEntity_1.IdentityEntity);
-            identities.map((identity) => __awaiter(this, void 0, void 0, function* () {
-                yield correlationIdentifierRepository
-                    .delete(identity.identifier.id)
-                    .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id ${identity.identifier.id}. ${error}`)));
-                if (identity.connection) {
-                    yield baseConfigRepository.delete(identity.connection.config.id);
-                    yield connectionRepository
-                        .delete(identity.connection.id)
-                        .catch((error) => { var _a; return Promise.reject(Error(`Unable to remove identity.connection with id ${(_a = identity.connection) === null || _a === void 0 ? void 0 : _a.id}. ${error}`)); });
-                }
-                if (identity.metadata) {
-                    identity.metadata.map((metadataItem) => __awaiter(this, void 0, void 0, function* () {
-                        yield identityMetadataItemRepository
-                            .delete(metadataItem.id)
-                            .catch((error) => Promise.reject(Error(`Unable to remove identity.metadataItem with id ${metadataItem.id}. ${error}`)));
-                    }));
-                }
-                yield identityRepository
-                    .delete(identity.id)
-                    .catch((error) => Promise.reject(Error(`Unable to remove identity with id ${identity.id}. ${error}`)));
-            }));
-        });
-        this.deleteElectronicAddresses = (electronicAddresses) => __awaiter(this, void 0, void 0, function* () {
-            debug('Removing electronic addresses', electronicAddresses);
-            const electronicAddressRepository = (yield this.dbConnection).getRepository(ElectronicAddressEntity_1.ElectronicAddressEntity);
-            electronicAddresses.map((electronicAddress) => __awaiter(this, void 0, void 0, function* () {
-                yield electronicAddressRepository
-                    .delete(electronicAddress.id)
-                    .catch((error) => Promise.reject(Error(`Unable to remove electronic address with id ${electronicAddress.id}. ${error}`)));
-            }));
-        });
-        this.deletePhysicalAddresses = (physicalAddresses) => __awaiter(this, void 0, void 0, function* () {
-            debug('Removing physical addresses', physicalAddresses);
-            const physicalAddressRepository = (yield this.dbConnection).getRepository(PhysicalAddressEntity_1.PhysicalAddressEntity);
-            physicalAddresses.map((physicalAddress) => __awaiter(this, void 0, void 0, function* () {
-                yield physicalAddressRepository
-                    .delete(physicalAddress.id)
-                    .catch((error) => Promise.reject(Error(`Unable to remove physical address with id ${physicalAddress.id}. ${error}`)));
-            }));
-        });
-        this.assertRelationshipSides = (leftId, rightId) => __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}`));
+            else if (typeof value === 'object' && value !== null) {
+                conditionObject[key] = this.processCondition(value);
             }
-            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}`));
+            else {
+                conditionObject[key] = value;
             }
         });
-        this.buildFilters = (filter) => {
-            if (!filter)
-                return {};
-            return filter.map((condition) => this.processCondition(condition));
+        return conditionObject;
+    };
+    buildMetadataCondition = (metadata) => {
+        const metadataCondition = {
+            label: metadata.label,
         };
-        this.processCondition = (condition) => {
-            const conditionObject = {};
-            Object.keys(condition).forEach((key) => {
-                const value = condition[key];
-                if (key === 'metadata' && value) {
-                    conditionObject[key] = this.buildMetadataCondition(value);
-                }
-                else if (typeof value === 'object' && value !== null) {
-                    conditionObject[key] = this.processCondition(value);
+        switch (typeof metadata.value) {
+            case 'string':
+                metadataCondition.stringValue = metadata.value;
+                break;
+            case 'number':
+                metadataCondition.numberValue = metadata.value;
+                break;
+            case 'boolean':
+                metadataCondition.boolValue = metadata.value;
+                break;
+            case 'object':
+                if (metadata.value instanceof Date) {
+                    metadataCondition.dateValue = metadata.value;
                 }
                 else {
-                    conditionObject[key] = value;
+                    // For now, we only support / implement not-primitive type Date in the entity
+                    throw new Error(`Unsupported object type: ${Object.prototype.toString.call(metadata.value).slice(8, -1)} for value ${metadata.value}`); // slice to extract type from string [object String]
                 }
-            });
-            return conditionObject;
-        };
-        this.buildMetadataCondition = (metadata) => {
-            const metadataCondition = {
-                label: metadata.label,
-            };
-            switch (typeof metadata.value) {
-                case 'string':
-                    metadataCondition.stringValue = metadata.value;
-                    break;
-                case 'number':
-                    metadataCondition.numberValue = metadata.value;
-                    break;
-                case 'boolean':
-                    metadataCondition.boolValue = metadata.value;
-                    break;
-                case 'object':
-                    if (metadata.value instanceof Date) {
-                        metadataCondition.dateValue = metadata.value;
-                    }
-                    else {
-                        // For now, we only support / implement not-primitive type Date in the entity
-                        throw new Error(`Unsupported object type: ${Object.prototype.toString.call(metadata.value).slice(8, -1)} for value ${metadata.value}`); // slice to extract type from string [object String]
-                    }
-                    break;
-                default:
-                    throw new Error(`Unsupported value type: ${typeof metadata.value}`);
-            }
-            return metadataCondition;
-        };
-        this.dbConnection = dbConnection;
-    }
+                break;
+            default:
+                throw new Error(`Unsupported value type: ${typeof metadata.value}`);
+        }
+        return metadataCondition;
+    };
 }
-exports.ContactStore = ContactStore;
 //# sourceMappingURL=ContactStore.js.map