@opra/elastic/elastic-adapter.js

Opra Elastic Search adapter package

import _prepareFilter from './adapter-utils/prepare-filter.js';
import _preparePatch from './adapter-utils/prepare-patch.js';
import _prepareProjection from './adapter-utils/prepare-projection.js';
import _prepareSort from './adapter-utils/prepare-sort.js';
export var ElasticAdapter;
(function (ElasticAdapter) {
    ElasticAdapter.prepareFilter = _prepareFilter;
    ElasticAdapter.preparePatch = _preparePatch;
    ElasticAdapter.prepareProjection = _prepareProjection;
    ElasticAdapter.prepareSort = _prepareSort;
    async function parseRequest(context) {
        if (context.transport !== 'http') {
            throw new TypeError('ElasticAdapter can parse only HttpContext');
        }
        const ctx = context;
        const { __oprDef } = ctx;
        if (__oprDef?.composition?.startsWith('Entity.') &&
            __oprDef.compositionOptions?.type) {
            const controller = __oprDef.owner;
            switch (__oprDef.composition) {
                case 'Entity.Create': {
                    const data = await ctx.getBody();
                    const options = {
                        projection: ctx.queryParams.projection,
                    };
                    return {
                        method: 'create',
                        data,
                        options,
                    };
                }
                case 'Entity.Delete': {
                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
                        controller.parameters.find(p => p.keyParam);
                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
                    const options = {
                        filter: ctx.queryParams.filter,
                    };
                    return {
                        method: 'delete',
                        key,
                        options,
                    };
                }
                case 'Entity.DeleteMany': {
                    const options = {
                        filter: ctx.queryParams.filter,
                    };
                    return { method: 'deleteMany', options };
                }
                case 'Entity.FindMany': {
                    const options = {
                        filter: ctx.queryParams.filter,
                        projection: ctx.queryParams.projection,
                        count: ctx.queryParams.count,
                        limit: ctx.queryParams.limit,
                        skip: ctx.queryParams.skip,
                        sort: ctx.queryParams.sort,
                    };
                    return { method: 'findMany', options };
                }
                case 'Entity.Get': {
                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
                        controller.parameters.find(p => p.keyParam);
                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
                    const options = {
                        projection: ctx.queryParams.projection,
                        filter: ctx.queryParams.filter,
                    };
                    return { method: 'get', key, options };
                }
                case 'Entity.Replace': {
                    const data = await ctx.getBody();
                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
                        controller.parameters.find(p => p.keyParam);
                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
                    const options = {
                        projection: ctx.queryParams.projection,
                        filter: ctx.queryParams.filter,
                    };
                    return {
                        method: 'replace',
                        key,
                        data,
                        options,
                    };
                }
                case 'Entity.Update': {
                    const data = await ctx.getBody();
                    const keyParam = __oprDef.parameters.find(p => p.keyParam) ||
                        controller.parameters.find(p => p.keyParam);
                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
                    const options = {
                        projection: ctx.queryParams.projection,
                        filter: ctx.queryParams.filter,
                    };
                    return {
                        method: 'update',
                        key,
                        data,
                        options,
                    };
                }
                case 'Entity.UpdateMany': {
                    const data = await ctx.getBody();
                    const options = {
                        filter: ctx.queryParams.filter,
                    };
                    return {
                        method: 'updateMany',
                        data,
                        options,
                    };
                }
                default:
                    break;
            }
        }
        throw new Error(`This operation is not compatible to Elastic adapter`);
    }
    ElasticAdapter.parseRequest = parseRequest;
})(ElasticAdapter || (ElasticAdapter = {}));