@dossierhq/sqlite-core/lib/admin-entity/unpublishEntities.js

A library used by concrete SQLite adapters for Dossier.

/// <reference types="./unpublishEntities.d.ts" />
/* eslint-disable @typescript-eslint/no-unused-expressions */
import { notOk, ok, } from '@dossierhq/core';
import { buildSqliteSqlQuery, createSqliteSqlQuery, } from '@dossierhq/database-adapter';
import { ENTITY_DIRTY_FLAG_INDEX_PUBLISHED, ENTITY_DIRTY_FLAG_VALIDATE_PUBLISHED, } from '../DatabaseSchema.js';
import { queryMany, queryRun } from '../QueryFunctions.js';
import { getTransactionTimestamp } from '../SqliteTransaction.js';
import { assertIsDefined } from '../utils/AssertUtils.js';
import { resolveEntityStatus } from '../utils/CodecUtils.js';
import { getEntitiesUpdatedSeq } from './getEntitiesUpdatedSeq.js';
export async function adminEntityUnpublishGetEntitiesInfo(database, context, references) {
    const { addValueList, query, sql } = createSqliteSqlQuery();
    const uuids = addValueList(references.map(({ id }) => id));
    sql `SELECT e.id, e.uuid, e.type, e.published_entity_versions_id, e.auth_key, e.resolved_auth_key, e.status, e.updated_at FROM entities e WHERE e.uuid IN ${uuids}`;
    const result = await queryMany(database, context, query);
    if (result.isError())
        return result;
    const entitiesInfo = result.value;
    const missingEntityIds = references
        .filter((reference) => !entitiesInfo.find((it) => it.uuid === reference.id))
        .map((it) => it.id);
    if (missingEntityIds.length > 0) {
        return notOk.NotFound(`No such entities: ${missingEntityIds.join(', ')}`);
    }
    return ok(references.map((reference) => {
        const entityInfo = entitiesInfo.find((it) => it.uuid === reference.id);
        assertIsDefined(entityInfo);
        assertIsDefined(entityInfo.uuid);
        return {
            id: entityInfo.uuid,
            entityInternalId: entityInfo.id,
            entityVersionInternalId: entityInfo.published_entity_versions_id,
            type: entityInfo.type,
            authKey: entityInfo.auth_key,
            resolvedAuthKey: entityInfo.resolved_auth_key,
            status: resolveEntityStatus(entityInfo.status),
            updatedAt: new Date(entityInfo.updated_at),
        };
    }));
}
export async function adminEntityUnpublishEntities(database, context, status, references, syncEvent) {
    const now = syncEvent?.createdAt ?? getTransactionTimestamp(context.transaction);
    const nowString = now.toISOString();
    const ids = references.map(({ entityInternalId }) => entityInternalId);
    for (const reference of references) {
        const updatedSeqResult = await getEntitiesUpdatedSeq(database, context);
        if (updatedSeqResult.isError())
            return updatedSeqResult;
        const updateEntityResult = await queryRun(database, context, buildSqliteSqlQuery(({ sql }) => {
            const dirty = ~(ENTITY_DIRTY_FLAG_VALIDATE_PUBLISHED | ENTITY_DIRTY_FLAG_INDEX_PUBLISHED);
            sql `UPDATE entities SET published_entity_versions_id = NULL, published_name = NULL, updated_at = ${nowString}, updated_seq = ${updatedSeqResult.value}, status = ${status}, invalid = invalid & ~2, dirty = dirty & ${dirty}`;
            sql `WHERE id = ${reference.entityInternalId}`;
        }));
        if (updateEntityResult.isError())
            return updateEntityResult;
    }
    const removeReferencesIndexResult = await queryRun(database, context, buildSqliteSqlQuery(({ sql, addValueList }) => {
        sql `DELETE FROM entity_published_references WHERE from_entities_id IN ${addValueList(ids)}`;
    }));
    if (removeReferencesIndexResult.isError())
        return removeReferencesIndexResult;
    const removeLocationsIndexResult = await queryRun(database, context, buildSqliteSqlQuery(({ sql, addValueList }) => {
        sql `DELETE FROM entity_published_locations WHERE entities_id IN ${addValueList(ids)}`;
    }));
    if (removeLocationsIndexResult.isError())
        return removeLocationsIndexResult;
    const removeValueTypesIndexResult = await queryRun(database, context, buildSqliteSqlQuery(({ sql, addValueList }) => {
        sql `DELETE FROM entity_published_value_types WHERE entities_id IN ${addValueList(ids)}`;
    }));
    if (removeValueTypesIndexResult.isError())
        return removeValueTypesIndexResult;
    const ftsResult = await queryRun(database, context, buildSqliteSqlQuery(({ sql, addValueList }) => {
        sql `DELETE FROM entities_published_fts WHERE rowid IN ${addValueList(ids)} `;
    }));
    if (ftsResult.isError())
        return ftsResult;
    return ok(references.map((reference) => {
        return { entityInternalId: reference.entityInternalId, updatedAt: now };
    }));
}
export async function adminEntityUnpublishGetPublishedReferencedEntities(database, context, reference) {
    const result = await queryMany(database, context, {
        text: `SELECT e.uuid
       FROM entity_published_references epr, entities e
       WHERE epr.to_entities_id = ?1
         AND epr.from_entities_id = e.id`,
        values: [reference.entityInternalId],
    });
    if (result.isError())
        return result;
    return result.map((row) => row.map(({ uuid }) => {
        assertIsDefined(uuid);
        return { id: uuid };
    }));
}
//# sourceMappingURL=unpublishEntities.js.map