@dossierhq/integration-test/lib/shared-entity/SearchTestUtils.js

Integration test to ensure that different Dossier database adapters work as expected.

/// <reference types="./SearchTestUtils.d.ts" />
import { EntityQueryOrder, EntityStatus, getAllPagesForConnection, ok, PublishedEntityQueryOrder, } from '@dossierhq/core';
import { assertEquals, assertOkResult, assertResultValue, assertSame, assertTruthy, } from '../Asserts.js';
const adminOrderCompare = {
    [EntityQueryOrder.createdAt]: (a, b) => a.info.createdAt.getTime() - b.info.createdAt.getTime(),
    [EntityQueryOrder.updatedAt]: (a, b) => a.info.updatedAt.getTime() - b.info.updatedAt.getTime(),
    [EntityQueryOrder.name]: (a, b) => a.info.name.localeCompare(b.info.name),
};
const adminOrderExtract = {
    [EntityQueryOrder.createdAt]: (it) => it.info.createdAt,
    [EntityQueryOrder.updatedAt]: (it) => it.info.updatedAt,
    [EntityQueryOrder.name]: (it) => it.info.name,
};
const publishedOrderCompare = {
    [PublishedEntityQueryOrder.createdAt]: (a, b) => a.info.createdAt.getTime() - b.info.createdAt.getTime(),
    [PublishedEntityQueryOrder.name]: (a, b) => a.info.name.localeCompare(b.info.name),
};
export function assertAdminEntityConnectionToMatchSlice(allEntities, connectionResult, sliceStart, sliceEnd, order, reverse) {
    const resolvedOrder = order ?? EntityQueryOrder.createdAt;
    const orderExtractor = adminOrderExtract[resolvedOrder];
    assertOkResult(connectionResult);
    const connection = connectionResult.value;
    const actualIds = connection?.edges.map((edge) => ({
        id: edge.node.isOk() ? edge.node.value.id : edge.node,
        order: edge.node.isOk() ? orderExtractor(edge.node.value) : null,
    }));
    const allEntitiesOrdered = [...allEntities].sort(adminOrderCompare[resolvedOrder]);
    if (reverse)
        allEntitiesOrdered.reverse();
    const expectedEntities = allEntitiesOrdered.slice(sliceStart, sliceEnd);
    const expectedIds = expectedEntities.map((it) => ({ id: it.id, order: orderExtractor(it) }));
    assertEquals(actualIds, expectedIds);
}
export function assertPublishedEntityConnectionToMatchSlice(allEntities, connectionResult, sliceStart, sliceEnd, order, reverse) {
    assertOkResult(connectionResult);
    const connection = connectionResult.value;
    const actualIds = connection?.edges.map((edge) => ({
        id: edge.node.isOk() ? edge.node.value.id : edge.node,
    }));
    const allEntitiesOrdered = [...allEntities].sort(publishedOrderCompare[order ?? PublishedEntityQueryOrder.createdAt]);
    if (reverse)
        allEntitiesOrdered.reverse();
    const expectedEntities = allEntitiesOrdered.slice(sliceStart, sliceEnd);
    const expectedIds = expectedEntities.map(({ id }) => ({ id }));
    assertEquals(actualIds, expectedIds);
}
export function assertSearchResultEntities(result, actualEntities) {
    assertOkResult(result);
    if (actualEntities.length === 0) {
        assertSame(result.value, null);
    }
    else {
        assertTruthy(result.value);
        assertEquals(result.value.edges.length, actualEntities.length);
        for (const [index, actualEntity] of actualEntities.entries()) {
            assertResultValue(result.value.edges[index].node, actualEntity);
        }
    }
}
export function assertPageInfoEquals(connectionResult, { hasNextPage, hasPreviousPage }) {
    assertOkResult(connectionResult);
    assertTruthy(connectionResult.value);
    const connection = connectionResult.value;
    assertEquals(connection.pageInfo, {
        startCursor: connection.edges[0].cursor,
        endCursor: connection.edges[connection.edges.length - 1].cursor,
        hasNextPage,
        hasPreviousPage,
    });
}
export async function countSearchResultWithEntity(client, query, entityId) {
    const result = await collectMatchingSearchResultNodes(client, query, (node) => node.isOk() && node.value.id === entityId);
    if (result.isError())
        return result;
    return ok(result.value.length);
}
export async function collectMatchingSearchResultNodes(client, query, matcher) {
    const matches = [];
    for await (const pageResult of getAllPagesForConnection({ first: 50 }, (currentPaging) => client.getEntities(query, currentPaging))) {
        if (pageResult.isError())
            return pageResult;
        for (const edge of pageResult.value.edges) {
            const node = edge.node;
            if (matcher(node)) {
                matches.push(node);
            }
        }
    }
    return ok(matches);
}
export async function countSearchResultStatuses(client, query) {
    const result = {
        [EntityStatus.draft]: 0,
        [EntityStatus.published]: 0,
        [EntityStatus.modified]: 0,
        [EntityStatus.withdrawn]: 0,
        [EntityStatus.archived]: 0,
        valid: 0,
        invalid: 0,
    };
    for await (const pageResult of getAllPagesForConnection({ first: 50 }, (currentPaging) => client.getEntities(query, currentPaging))) {
        if (pageResult.isError()) {
            return pageResult;
        }
        for (const edge of pageResult.value.edges) {
            if (edge.node.isOk()) {
                const entity = edge.node.value;
                result[entity.info.status] += 1;
                if (entity.info.valid && entity.info.validPublished !== false) {
                    result.valid += 1;
                }
                else {
                    result.invalid += 1;
                }
            }
        }
    }
    return ok(result);
}
//# sourceMappingURL=SearchTestUtils.js.map