@opra/core 0.1.0 → 0.2.0

package/esm/interfaces/query.interface.js

@@ -1,203 +0,0 @@
-import _ from 'lodash';
-import { ComplexType } from '@opra/schema';
-import { pathToTree } from '../utils/path-to-tree.js';
-export var OpraQuery;
-(function (OpraQuery) {
-    function forCreate(resource, values, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        const out = {
-            queryType: 'create',
-            scope: 'collection',
-            operation: 'create',
-            resource,
-            data: values
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forCreate = forCreate;
-    function forGetSchema(resourcePath, options) {
-        // if (options?.pick)
-        //   options.pick = normalizePick(resource, options.pick);
-        // if (options?.omit)
-        //   options.omit = normalizePick(resource, options.omit);
-        // if (options?.include)
-        //   options.include = normalizePick(resource, options.include);
-        const out = {
-            queryType: 'schema',
-            scope: 'instance',
-            resourcePath,
-            operation: 'read',
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forGetSchema = forGetSchema;
-    function forGetEntity(resource, key, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        checkKeyFields(resource, key);
-        const out = {
-            queryType: 'get',
-            scope: 'instance',
-            operation: 'read',
-            resource,
-            keyValue: key
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forGetEntity = forGetEntity;
-    function forSearch(resource, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        if (options?.sort)
-            options.sort = normalizePick(resource, options.sort); // todo check allowed sort fields
-        const out = {
-            queryType: 'search',
-            scope: 'collection',
-            operation: 'read',
-            resource
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forSearch = forSearch;
-    function forGetProperty(property, options) {
-        const out = {
-            queryType: 'get',
-            scope: 'property',
-            operation: 'read',
-            property
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forGetProperty = forGetProperty;
-    function forUpdate(resource, keyValue, values, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        checkKeyFields(resource, keyValue);
-        const out = {
-            queryType: 'update',
-            scope: 'instance',
-            operation: 'update',
-            resource,
-            keyValue,
-            data: values
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forUpdate = forUpdate;
-    function forUpdateMany(resource, values, options) {
-        const out = {
-            queryType: 'updateMany',
-            scope: 'collection',
-            operation: 'update',
-            resource,
-            data: values
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forUpdateMany = forUpdateMany;
-    function forDelete(resource, key) {
-        checkKeyFields(resource, key);
-        return {
-            queryType: 'delete',
-            scope: 'instance',
-            operation: 'delete',
-            resource,
-            keyValue: key
-        };
-    }
-    OpraQuery.forDelete = forDelete;
-    function forDeleteMany(resource, options) {
-        const out = {
-            queryType: 'deleteMany',
-            scope: 'collection',
-            operation: 'delete',
-            resource,
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forDeleteMany = forDeleteMany;
-    function isCreateQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'create';
-    }
-    OpraQuery.isCreateQuery = isCreateQuery;
-    function isSearchQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'search';
-    }
-    OpraQuery.isSearchQuery = isSearchQuery;
-    function isReadQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'read';
-    }
-    OpraQuery.isReadQuery = isReadQuery;
-    function isDeleteQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'delete';
-    }
-    OpraQuery.isDeleteQuery = isDeleteQuery;
-})(OpraQuery || (OpraQuery = {}));
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function checkKeyFields(resource, key) {
-    if (!resource.dataType.primaryKey)
-        throw new Error(`"${resource.name}" has no primary key`);
-}
-function normalizePick(resource, fields) {
-    const fieldsTree = pathToTree(fields) || {};
-    return _normalizeFieldsList([], resource.service, resource, resource.dataType, fieldsTree, '', {
-        additionalFields: true
-    });
-}
-function _normalizeFieldsList(target, service, resource, dataType, node, parentPath = '', options) {
-    let curPath = '';
-    for (const k of Object.keys(node)) {
-        const nodeVal = node[k];
-        const prop = dataType?.fields.get(k);
-        if (!prop) {
-            curPath = parentPath ? parentPath + '.' + k : k;
-            if (!options?.additionalFields || (dataType && !dataType.additionalFields))
-                throw new TypeError(`Unknown field path "${resource.name + '.' + curPath}"`);
-            if (typeof nodeVal === 'object')
-                _normalizeFieldsList(target, service, resource, undefined, nodeVal, curPath, options);
-            else
-                target.push(curPath);
-            continue;
-        }
-        curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
-        const propType = service.getDataType(prop.type || 'string');
-        if (typeof nodeVal === 'object') {
-            if (!(propType && propType instanceof ComplexType))
-                throw new TypeError(`"${curPath}" is not a complex type and has no sub fields`);
-            if (target.findIndex(x => x === parentPath) >= 0)
-                continue;
-            target = _normalizeFieldsList(target, service, resource, propType, nodeVal, curPath, options);
-            continue;
-        }
-        if (target.findIndex(x => x.startsWith(curPath + '.')) >= 0) {
-            target = target.filter(x => !x.startsWith(curPath + '.'));
-        }
-        target.push(curPath);
-    }
-    return target;
-}