@opra/sqb/esm/sqb-adapter.js

Opra SQB adapter package

import { EntityMetadata } from '@sqb/connect';
import _prepareFilter from './adapter-utils/prepare-filter.js';
export var SQBAdapter;
(function (SQBAdapter) {
    /**
     * @deprecated Use prepareFilter instead
     */
    SQBAdapter.parseFilter = _prepareFilter;
    SQBAdapter.prepareFilter = _prepareFilter;
    async function parseRequest(context) {
        if (context.protocol !== 'http') {
            throw new TypeError('SQBAdapter can parse only HttpContext');
        }
        const ctx = context;
        const { operation } = ctx;
        if (operation?.composition?.startsWith('Entity.') &&
            operation.compositionOptions?.type) {
            const dataType = ctx.document.node.getComplexType(operation.compositionOptions?.type);
            const entityMetadata = EntityMetadata.get(dataType.ctor);
            if (!entityMetadata)
                throw new Error(`Type class "${dataType.ctor}" is not an SQB entity`);
            const controller = operation.owner;
            switch (operation.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 = operation.parameters.find(p => p.keyParam) ||
                        controller.parameters.find(p => p.keyParam);
                    const key = keyParam && ctx.pathParams[String(keyParam.name)];
                    const options = {
                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
                    };
                    return {
                        method: 'delete',
                        key,
                        options,
                    };
                }
                case 'Entity.DeleteMany': {
                    const options = {
                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
                    };
                    return { method: 'deleteMany', options };
                }
                case 'Entity.FindMany': {
                    const options = {
                        count: ctx.queryParams.count,
                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
                        projection: ctx.queryParams.projection ||
                            operation.compositionOptions.defaultProjection,
                        limit: ctx.queryParams.limit ||
                            operation.compositionOptions.defaultLimit,
                        skip: ctx.queryParams.skip,
                        sort: ctx.queryParams.sort || operation.compositionOptions.defaultSort,
                    };
                    return { method: 'findMany', options };
                }
                case 'Entity.Get': {
                    const keyParam = operation.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: SQBAdapter.parseFilter(ctx.queryParams.filter),
                    };
                    return { method: 'get', key, options };
                }
                case 'Entity.Replace': {
                    const data = await ctx.getBody();
                    const keyParam = operation.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 = operation.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: SQBAdapter.parseFilter(ctx.queryParams.filter),
                    };
                    return {
                        method: 'update',
                        key,
                        data,
                        options,
                    };
                }
                case 'Entity.UpdateMany': {
                    const data = await ctx.getBody();
                    const options = {
                        filter: SQBAdapter.parseFilter(ctx.queryParams.filter),
                    };
                    return {
                        method: 'updateMany',
                        data,
                        options,
                    };
                }
                default:
                    break;
            }
        }
        throw new Error(`This operation is not compatible to SQB Adapter`);
    }
    SQBAdapter.parseRequest = parseRequest;
})(SQBAdapter || (SQBAdapter = {}));