@dossierhq/core/lib/client/DossierClient.js

The core Dossier library used by clients and server alike, used to interact with schema and entities directly, as well as remotely through a client.

/// <reference types="./DossierClient.d.ts" />
import { ErrorType, notOk, ok, } from '../ErrorResult.js';
import { convertJsonChangelogEventEdge, convertJsonConnection, convertJsonDeletePayload, convertJsonEdge, convertJsonEntity, convertJsonPublishingPayload, convertJsonResult, } from './JsonUtils.js';
import { executeOperationPipeline, } from './SharedClient.js';
export const DossierClientOperationName = {
    acquireAdvisoryLock: 'acquireAdvisoryLock',
    archiveEntity: 'archiveEntity',
    createEntity: 'createEntity',
    deleteEntities: 'deleteEntities',
    getChangelogEvents: 'getChangelogEvents',
    getChangelogEventsTotalCount: 'getChangelogEventsTotalCount',
    getEntities: 'getEntities',
    getEntitiesSample: 'getEntitiesSample',
    getEntitiesTotalCount: 'getEntitiesTotalCount',
    getEntity: 'getEntity',
    getEntityList: 'getEntityList',
    getSchemaSpecification: 'getSchemaSpecification',
    processDirtyEntity: 'processDirtyEntity',
    publishEntities: 'publishEntities',
    releaseAdvisoryLock: 'releaseAdvisoryLock',
    renewAdvisoryLock: 'renewAdvisoryLock',
    unarchiveEntity: 'unarchiveEntity',
    unpublishEntities: 'unpublishEntities',
    updateEntity: 'updateEntity',
    updateSchemaSpecification: 'updateSchemaSpecification',
    upsertEntity: 'upsertEntity',
};
export const DossierClientModifyingOperations = /* @__PURE__ */ (() => new Set([
    DossierClientOperationName.acquireAdvisoryLock,
    DossierClientOperationName.archiveEntity,
    DossierClientOperationName.createEntity,
    DossierClientOperationName.deleteEntities,
    DossierClientOperationName.processDirtyEntity,
    DossierClientOperationName.publishEntities,
    DossierClientOperationName.releaseAdvisoryLock,
    DossierClientOperationName.renewAdvisoryLock,
    DossierClientOperationName.unarchiveEntity,
    DossierClientOperationName.unpublishEntities,
    DossierClientOperationName.updateEntity,
    DossierClientOperationName.updateSchemaSpecification,
    DossierClientOperationName.upsertEntity,
]))();
class BaseDossierClient {
    context;
    pipeline;
    constructor({ context, pipeline, }) {
        this.context = context;
        this.pipeline = pipeline;
    }
    getSchemaSpecification(options) {
        return this.executeOperation({
            name: DossierClientOperationName.getSchemaSpecification,
            args: [options],
            modifies: false,
        });
    }
    updateSchemaSpecification(schemaSpec, options) {
        return this.executeOperation({
            name: DossierClientOperationName.updateSchemaSpecification,
            args: [schemaSpec, options],
            modifies: true,
        });
    }
    getEntity(reference) {
        return this.executeOperation({
            name: DossierClientOperationName.getEntity,
            args: [reference],
            modifies: false,
        });
    }
    getEntityList(references) {
        return this.executeOperation({
            name: DossierClientOperationName.getEntityList,
            args: [references],
            modifies: false,
        });
    }
    getEntities(query, paging) {
        return this.executeOperation({
            name: DossierClientOperationName.getEntities,
            args: [query, paging],
            modifies: false,
        });
    }
    getEntitiesTotalCount(query) {
        return this.executeOperation({
            name: DossierClientOperationName.getEntitiesTotalCount,
            args: [query],
            modifies: false,
        });
    }
    getEntitiesSample(query, options) {
        return this.executeOperation({
            name: DossierClientOperationName.getEntitiesSample,
            args: [query, options],
            modifies: false,
        });
    }
    createEntity(entity, options) {
        return this.executeOperation({
            name: DossierClientOperationName.createEntity,
            args: [entity, options],
            modifies: true,
        });
    }
    updateEntity(entity, options) {
        return this.executeOperation({
            name: DossierClientOperationName.updateEntity,
            args: [entity, options],
            modifies: true,
        });
    }
    upsertEntity(entity, options) {
        return this.executeOperation({
            name: DossierClientOperationName.upsertEntity,
            args: [entity, options],
            modifies: true,
        });
    }
    getChangelogEvents(query, paging) {
        return this.executeOperation({
            name: DossierClientOperationName.getChangelogEvents,
            args: [query, paging],
            modifies: false,
        });
    }
    getChangelogEventsTotalCount(query) {
        return this.executeOperation({
            name: DossierClientOperationName.getChangelogEventsTotalCount,
            args: [query],
            modifies: false,
        });
    }
    publishEntities(references) {
        return this.executeOperation({
            name: DossierClientOperationName.publishEntities,
            args: [references],
            modifies: true,
        });
    }
    unpublishEntities(references) {
        return this.executeOperation({
            name: DossierClientOperationName.unpublishEntities,
            args: [references],
            modifies: true,
        });
    }
    archiveEntity(reference) {
        return this.executeOperation({
            name: DossierClientOperationName.archiveEntity,
            args: [reference],
            modifies: true,
        });
    }
    unarchiveEntity(reference) {
        return this.executeOperation({
            name: DossierClientOperationName.unarchiveEntity,
            args: [reference],
            modifies: true,
        });
    }
    deleteEntities(references) {
        return this.executeOperation({
            name: DossierClientOperationName.deleteEntities,
            args: [references],
            modifies: true,
        });
    }
    processDirtyEntity(reference) {
        return this.executeOperation({
            name: DossierClientOperationName.processDirtyEntity,
            args: [reference],
            modifies: true,
        });
    }
    acquireAdvisoryLock(name, options) {
        return this.executeOperation({
            name: DossierClientOperationName.acquireAdvisoryLock,
            args: [name, options],
            modifies: true,
        });
    }
    renewAdvisoryLock(name, handle) {
        return this.executeOperation({
            name: DossierClientOperationName.renewAdvisoryLock,
            args: [name, handle],
            modifies: true,
        });
    }
    releaseAdvisoryLock(name, handle) {
        return this.executeOperation({
            name: DossierClientOperationName.releaseAdvisoryLock,
            args: [name, handle],
            modifies: true,
        });
    }
    toExceptionClient() {
        return new DossierExceptionClientWrapper(this);
    }
    async executeOperation(operation) {
        let context;
        if (typeof this.context === 'function') {
            const contextResult = await this.context();
            if (contextResult.isError()) {
                if (contextResult.isErrorType(ErrorType.Generic)) {
                    return contextResult;
                }
                //TODO maybe operation should have a list of supported error types?
                return notOk.GenericUnexpectedError(contextResult);
            }
            context = contextResult.value.context;
        }
        else {
            context = this.context;
        }
        return await executeOperationPipeline(context, this.pipeline, operation);
    }
}
class DossierExceptionClientWrapper {
    client;
    constructor(client) {
        this.client = client;
    }
    async getSchemaSpecification(options) {
        return (await this.client.getSchemaSpecification(options)).valueOrThrow();
    }
    async updateSchemaSpecification(schemaSpec, options) {
        return (await this.client.updateSchemaSpecification(schemaSpec, options)).valueOrThrow();
    }
    async getEntity(reference) {
        return (await this.client.getEntity(reference)).valueOrThrow();
    }
    async getEntityList(references) {
        return (await this.client.getEntityList(references)).valueOrThrow();
    }
    async getEntities(query, paging) {
        return (await this.client.getEntities(query, paging)).valueOrThrow();
    }
    async getEntitiesTotalCount(query) {
        return (await this.client.getEntitiesTotalCount(query)).valueOrThrow();
    }
    async getEntitiesSample(query, options) {
        return (await this.client.getEntitiesSample(query, options)).valueOrThrow();
    }
    async createEntity(entity, options) {
        return (await this.client.createEntity(entity, options)).valueOrThrow();
    }
    async updateEntity(entity, options) {
        return (await this.client.updateEntity(entity, options)).valueOrThrow();
    }
    async upsertEntity(entity, options) {
        return (await this.client.upsertEntity(entity, options)).valueOrThrow();
    }
    async getChangelogEvents(query, paging) {
        return (await this.client.getChangelogEvents(query, paging)).valueOrThrow();
    }
    async getChangelogEventsTotalCount(query) {
        return (await this.client.getChangelogEventsTotalCount(query)).valueOrThrow();
    }
    async publishEntities(references) {
        return (await this.client.publishEntities(references)).valueOrThrow();
    }
    async unpublishEntities(references) {
        return (await this.client.unpublishEntities(references)).valueOrThrow();
    }
    async archiveEntity(reference) {
        return (await this.client.archiveEntity(reference)).valueOrThrow();
    }
    async unarchiveEntity(reference) {
        return (await this.client.unarchiveEntity(reference)).valueOrThrow();
    }
    async deleteEntities(references) {
        return (await this.client.deleteEntities(references)).valueOrThrow();
    }
    async processDirtyEntity(reference) {
        return (await this.client.processDirtyEntity(reference)).valueOrThrow();
    }
    async acquireAdvisoryLock(name, options) {
        return (await this.client.acquireAdvisoryLock(name, options)).valueOrThrow();
    }
    async renewAdvisoryLock(name, handle) {
        return (await this.client.renewAdvisoryLock(name, handle)).valueOrThrow();
    }
    async releaseAdvisoryLock(name, handle) {
        return (await this.client.releaseAdvisoryLock(name, handle)).valueOrThrow();
    }
}
export function createBaseDossierClient(option) {
    return new BaseDossierClient(option);
}
export async function executeJsonDossierClientOperation(client, operationName, operationArgs) {
    const name = operationName;
    switch (name) {
        case DossierClientOperationName.acquireAdvisoryLock: {
            const [name, options] = operationArgs;
            return await client.acquireAdvisoryLock(name, options);
        }
        case DossierClientOperationName.archiveEntity: {
            const [reference] = operationArgs;
            return await client.archiveEntity(reference);
        }
        case DossierClientOperationName.createEntity: {
            const [entity, options] = operationArgs;
            return await client.createEntity(entity, options);
        }
        case DossierClientOperationName.deleteEntities: {
            const [reference] = operationArgs;
            return await client.deleteEntities(reference);
        }
        case DossierClientOperationName.getChangelogEvents: {
            const [query, paging] = operationArgs;
            return await client.getChangelogEvents(query, paging);
        }
        case DossierClientOperationName.getChangelogEventsTotalCount: {
            const [query] = operationArgs;
            return await client.getChangelogEventsTotalCount(query);
        }
        case DossierClientOperationName.getEntities: {
            const [query, paging] = operationArgs;
            return await client.getEntities(query, paging);
        }
        case DossierClientOperationName.getEntitiesSample: {
            const [query, options] = operationArgs;
            return await client.getEntitiesSample(query, options);
        }
        case DossierClientOperationName.getEntitiesTotalCount: {
            const [query] = operationArgs;
            return await client.getEntitiesTotalCount(query);
        }
        case DossierClientOperationName.getEntity: {
            const [reference] = operationArgs;
            return await client.getEntity(reference);
        }
        case DossierClientOperationName.getEntityList: {
            const [references] = operationArgs;
            return await client.getEntityList(references);
        }
        case DossierClientOperationName.getSchemaSpecification: {
            const [options] = operationArgs;
            return await client.getSchemaSpecification(options);
        }
        case DossierClientOperationName.processDirtyEntity: {
            const [reference] = operationArgs;
            return await client.processDirtyEntity(reference);
        }
        case DossierClientOperationName.publishEntities: {
            const [references] = operationArgs;
            return await client.publishEntities(references);
        }
        case DossierClientOperationName.releaseAdvisoryLock: {
            const [name, handle] = operationArgs;
            return await client.releaseAdvisoryLock(name, handle);
        }
        case DossierClientOperationName.renewAdvisoryLock: {
            const [name, handle] = operationArgs;
            return await client.renewAdvisoryLock(name, handle);
        }
        case DossierClientOperationName.unarchiveEntity: {
            const [reference] = operationArgs;
            return await client.unarchiveEntity(reference);
        }
        case DossierClientOperationName.unpublishEntities: {
            const [references] = operationArgs;
            return await client.unpublishEntities(references);
        }
        case DossierClientOperationName.updateEntity: {
            const [entity, options] = operationArgs;
            return await client.updateEntity(entity, options);
        }
        case DossierClientOperationName.updateSchemaSpecification: {
            const [schemaSpec, options] = operationArgs;
            return await client.updateSchemaSpecification(schemaSpec, options);
        }
        case DossierClientOperationName.upsertEntity: {
            const [entity, options] = operationArgs;
            return await client.upsertEntity(entity, options);
        }
        default: {
            name;
            return notOk.BadRequest(`Unknown operation ${operationName}`);
        }
    }
}
export function convertJsonDossierClientResult(operationName, jsonResult) {
    if (jsonResult.isError()) {
        //TODO check expected types
        return jsonResult;
    }
    const { value } = jsonResult;
    switch (operationName) {
        case DossierClientOperationName.acquireAdvisoryLock: {
            const result = ok(value);
            return result;
        }
        case DossierClientOperationName.archiveEntity: {
            const result = ok(convertJsonPublishingPayload(value));
            return result;
        }
        case DossierClientOperationName.createEntity: {
            const valueTyped = value;
            const result = ok({
                ...valueTyped,
                entity: convertJsonEntity(valueTyped.entity),
            });
            return result;
        }
        case DossierClientOperationName.deleteEntities: {
            const result = ok(convertJsonDeletePayload(value));
            return result;
        }
        case DossierClientOperationName.getChangelogEvents: {
            const result = ok(convertJsonConnection(value, convertJsonChangelogEventEdge));
            return result;
        }
        case DossierClientOperationName.getChangelogEventsTotalCount: {
            return ok(value);
        }
        case DossierClientOperationName.getEntities: {
            const result = ok(convertJsonConnection(value, convertJsonEntityEdge));
            return result;
        }
        case DossierClientOperationName.getEntitiesSample: {
            const payload = value;
            const result = ok({
                ...payload,
                items: payload.items.map((it) => convertJsonEntity(it)),
            });
            return result;
        }
        case DossierClientOperationName.getEntitiesTotalCount:
            return ok(value);
        case DossierClientOperationName.getEntity: {
            const result = ok(convertJsonEntity(value));
            return result;
        }
        case DossierClientOperationName.getEntityList: {
            const result = ok(value.map((jsonItemResult) => {
                const itemResult = convertJsonResult(jsonItemResult);
                return itemResult.isOk() ? itemResult.map(convertJsonEntity) : itemResult;
            }));
            return result;
        }
        case DossierClientOperationName.getSchemaSpecification:
            return ok(value);
        case DossierClientOperationName.processDirtyEntity: {
            const result = ok(value);
            return result;
        }
        case DossierClientOperationName.publishEntities: {
            const result = ok(value.map(convertJsonPublishingPayload));
            return result;
        }
        case DossierClientOperationName.releaseAdvisoryLock: {
            const result = ok(value);
            return result;
        }
        case DossierClientOperationName.renewAdvisoryLock: {
            const result = ok(value);
            return result;
        }
        case DossierClientOperationName.unarchiveEntity: {
            const result = ok(convertJsonPublishingPayload(value));
            return result;
        }
        case DossierClientOperationName.unpublishEntities: {
            const result = ok(value.map(convertJsonPublishingPayload));
            return result;
        }
        case DossierClientOperationName.updateEntity: {
            const valueTyped = value;
            const result = ok({
                ...valueTyped,
                entity: convertJsonEntity(valueTyped.entity),
            });
            return result;
        }
        case DossierClientOperationName.updateSchemaSpecification:
            return ok(value);
        case DossierClientOperationName.upsertEntity: {
            const valueTyped = value;
            const result = ok({
                ...valueTyped,
                entity: convertJsonEntity(valueTyped.entity),
            });
            return result;
        }
        default: {
            operationName;
            return notOk.Generic(`Unknown operation ${operationName}`);
        }
    }
}
function convertJsonEntityEdge(edge) {
    return convertJsonEdge(edge, convertJsonEntity);
}
//# sourceMappingURL=DossierClient.js.map