@sphereon/ssi-sdk.data-store/dist/contact/ContactStore.js

"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 {
    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) {
                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`));
                }
            }
            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 },
            });
            if (!party) {
                return Promise.reject(Error(`No party found for id: ${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}`));
            }
            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}`));
            }
            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}`));
            }
            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 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}`));
            }
            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 },
            });
            if (!physicalAddress) {
                return Promise.reject(Error(`No physical address found for id: ${physicalAddressId}`));
            }
            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');
            }
        };
        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');
            }
        };
        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}`));
            }
            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}`));
            }
        });
        this.buildFilters = (filter) => {
            if (!filter)
                return {};
            return filter.map((condition) => this.processCondition(condition));
        };
        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);
                }
                else {
                    conditionObject[key] = value;
                }
            });
            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;
    }
}
exports.ContactStore = ContactStore;
//# sourceMappingURL=ContactStore.js.map