@rockster/core 0.0.1

package/query/decorators/query-content.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryContent = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const constants_1 = require("../constants");
+const QueryContent = () => {
+    return (target, propertyKey, index) => {
+        (0, class_injector_1.Inject)(constants_1.QUERY_CONTENT_KEY)(target, propertyKey, index);
+    };
+};
+exports.QueryContent = QueryContent;

package/query/functions/add-join.d.ts

@@ -0,0 +1,5 @@
+import { Dictionary, Instantiable } from "@rockster/common";
+import { IQueryContent, QueryPath } from "../interfaces/query";
+import { SelectQueryBuilder } from "../../database/extensions/select-query-builder";
+import { EntityManager } from "typeorm/entity-manager/EntityManager";
+export declare const addJoin: (RootEntity: Instantiable, queryContent: IQueryContent<any>, joins: Dictionary<boolean>, queryBuilder: SelectQueryBuilder<any>, path: QueryPath, entityManager: EntityManager) => void;

package/query/functions/add-join.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addJoin = void 0;
+const use_protector_1 = require("../../database/functions/use-protector");
+const addJoin = (RootEntity, queryContent, joins, queryBuilder, path, entityManager) => {
+    if (path.type === "embedded") {
+        (0, exports.addJoin)(RootEntity, queryContent, joins, queryBuilder, path.parent, entityManager);
+    }
+    const wasAdded = joins[path.alias];
+    if (path.type === 'relation' && !wasAdded) {
+        if (path.parent) {
+            (0, exports.addJoin)(RootEntity, queryContent, joins, queryBuilder, path.parent, entityManager);
+        }
+        const protector = (0, use_protector_1.useProtector)(path.target);
+        const secure = path.secure && protector
+            ? protector
+                .relationCondition({
+                userId: queryContent.userId,
+                contextParams: queryContent.context,
+                alias: path.entityAlias,
+                rootPath: RootEntity
+            })
+            : '';
+        const condition = typeof path.relation.condition === 'string'
+            ? path
+                .relation
+                .condition
+            : path
+                .relation
+                .condition(queryBuilder, queryContent, entityManager);
+        path.relation.type === "direct"
+            ? queryBuilder.leftJoinAndMapOne(path.relation.mapTo, path.target, path.entityAlias, condition + ` ${secure}`)
+            : queryBuilder.leftJoinAndMapMany(path.relation.mapTo, path.target, path.entityAlias, condition + ` ${secure}`);
+        joins[path.alias] = true;
+    }
+};
+exports.addJoin = addJoin;

package/query/functions/create-query-builder.d.ts

@@ -0,0 +1,4 @@
+import { QueryInterceptHandle } from "./execute-query";
+import { SelectQueryBuilder } from "../../database/extensions/select-query-builder";
+import { IQueryContent } from "../interfaces/query";
+export declare const createQueryBuilder: <Entity>(queryContent: IQueryContent<Entity>, intercept: QueryInterceptHandle<Entity>) => Promise<SelectQueryBuilder<Entity>>;

package/query/functions/create-query-builder.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueryBuilder = void 0;
+const use_repository_1 = require("../../database/functions/use-repository");
+const use_protector_1 = require("../../database/functions/use-protector");
+const add_join_1 = require("./add-join");
+const get_column_path_1 = require("./get-column-path");
+const get_native_select_1 = require("./get-native-select");
+const select_query_builder_1 = require("../../database/extensions/select-query-builder");
+const transaction_context_1 = require("../../database/contexts/transaction-context");
+const createQueryBuilder = async (queryContent, intercept) => {
+    const object = core
+        .storage
+        .findObject(queryContent.target);
+    const RootEntity = object.rootPath.target();
+    const requestContext = transaction_context_1.transactionContextStore.getStore();
+    const entityManager = requestContext?.entityManager;
+    const repository = entityManager
+        ? entityManager.getRepository(RootEntity)
+        : (0, use_repository_1.useRepository)(RootEntity);
+    const queryBuilder = new select_query_builder_1.SelectQueryBuilder(repository.createQueryBuilder(object.rootPath.alias));
+    if (intercept) {
+        await intercept(queryBuilder);
+    }
+    const rootProtector = (0, use_protector_1.useProtector)(RootEntity);
+    if (object.rootPath.secure && rootProtector) {
+        rootProtector.rootCondition({
+            rootAlias: object.rootPath.alias,
+            queryBuilder: queryBuilder,
+            userId: queryContent.userId,
+            contextParams: queryContent.context
+        });
+    }
+    const joins = {};
+    const select = [...queryContent.query.select];
+    for (const name of queryContent.query.select) {
+        const property = object.properties[name];
+        (0, add_join_1.addJoin)(RootEntity, queryContent, joins, queryBuilder, property.path, entityManager);
+        switch (property.path.type) {
+            case "relation":
+            case "root":
+                (0, add_join_1.addJoin)(RootEntity, queryContent, joins, queryBuilder, property.path, entityManager);
+                break;
+            case "embedded":
+                const columnPath = (0, get_column_path_1.getColumnPath)(property.path);
+                select.pushIfNotExists(columnPath);
+                break;
+        }
+    }
+    queryContent.rootAlias = object.rootPath.alias;
+    queryContent.naviteSelect = (0, get_native_select_1.getNativeSelect)(queryContent.target, queryContent.query.select).distinct();
+    return queryBuilder;
+};
+exports.createQueryBuilder = createQueryBuilder;

package/query/functions/create-query.d.ts

@@ -0,0 +1,5 @@
+import { DirectPath, IndirectPath, RootPath } from "../../database";
+import { QueryActionOptions } from "../interfaces/query-action-options";
+export declare const createQuery: <Entity>(rootPath: RootPath<Entity>) => (options?: QueryActionOptions) => (target: any, propertyKey: string) => void;
+export declare const directPath: <Entity>(path: Omit<DirectPath<Entity>, "type">) => DirectPath<Entity>;
+export declare const indirectPath: <Entity>(path: Omit<IndirectPath<Entity>, "type">) => IndirectPath<Entity>;

package/query/functions/create-query.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indirectPath = exports.directPath = exports.createQuery = void 0;
+const class_pipe_1 = require("@rockster/class-pipe");
+const database_1 = require("../../database");
+const interfaces_1 = require("../../common/interfaces");
+const create_new_class_1 = require("../../database/functions/create-new-class");
+const class_injector_1 = require("@rockster/class-injector");
+const constants_1 = require("../constants");
+const base_query_response_1 = require("../models/base-query-response");
+const load_properties_1 = require("./load-properties");
+const aliasToName = (alias) => {
+    const firstLetter = alias[0].toUpperCase();
+    return firstLetter + alias.substring(1, alias.length);
+};
+const createQuery = (rootPath) => {
+    // Properties
+    const name = aliasToName(rootPath.alias);
+    const QueryRequest = (0, create_new_class_1.createNewClass)(`${name}Query`, rootPath.context
+        ? rootPath.context()
+        : rootPath.contextData);
+    const QueryResponse = (0, create_new_class_1.createNewClass)(`${name}QueryResponse`, base_query_response_1.BaseQueryResponse);
+    const QueryOrderBy = (0, create_new_class_1.createNewClass)(`${QueryRequest.name}OrderBy`);
+    const Target = rootPath.target();
+    const properties = {};
+    (0, load_properties_1.loadProperties)({
+        type: 'root',
+        target: Target,
+        properties,
+        alias: rootPath.alias,
+        entityAlias: rootPath.alias,
+        paths: rootPath.paths,
+        secure: rootPath.secure,
+        rootEntity: Target
+    });
+    // Data of response
+    (0, class_pipe_1.IsType)(() => Target)(QueryResponse.prototype, 'data');
+    // Select
+    (0, class_pipe_1.IsIn)(Object.getOwnPropertyNames(properties))(QueryRequest.prototype, 'select');
+    (0, class_pipe_1.IsArray)({ min: 1 })(QueryRequest.prototype, 'select');
+    (0, class_pipe_1.IsRequired)()(QueryRequest.prototype, 'select');
+    // Take
+    (0, class_pipe_1.IsInt)()(QueryRequest.prototype, 'take');
+    (0, class_pipe_1.IsOptional)()(QueryRequest.prototype, 'take');
+    // Skip
+    (0, class_pipe_1.IsInt)()(QueryRequest.prototype, 'skip');
+    (0, class_pipe_1.IsOptional)()(QueryRequest.prototype, 'skip');
+    // OrderBy.direction
+    (0, class_pipe_1.IsIn)(Object.getOwnPropertyNames(database_1.OrderByDirection))(QueryOrderBy.prototype, 'direction');
+    (0, class_pipe_1.IsRequired)()(QueryOrderBy.prototype, 'direction');
+    // OrderBy.property
+    (0, class_pipe_1.IsIn)(Object.getOwnPropertyNames(properties))(QueryOrderBy.prototype, 'property');
+    (0, class_pipe_1.IsRequired)()(QueryOrderBy.prototype, 'property');
+    // OrderBy
+    (0, class_pipe_1.IsType)(() => QueryOrderBy)(QueryRequest.prototype, 'orderBy');
+    (0, class_pipe_1.IsArray)({ min: 1 })(QueryRequest.prototype, 'orderBy');
+    (0, class_pipe_1.IsOptional)()(QueryRequest.prototype, 'orderBy');
+    // Page
+    (0, class_pipe_1.IsBoolean)()(QueryRequest.prototype, 'page');
+    (0, class_pipe_1.IsOptional)()(QueryRequest.prototype, 'page');
+    const object = core
+        .storage
+        .createObject(QueryRequest);
+    object.properties = properties;
+    object.rootPath = rootPath;
+    return (options) => {
+        return (target, propertyKey) => {
+            const property = core
+                .storage
+                .createProperty(target, propertyKey);
+            property.type = interfaces_1.PropertyType.request;
+            property.name = options?.name || propertyKey;
+            property.public = options?.public || false;
+            property.description = options?.description;
+            property.actionType = constants_1.QUERY_ACTION_TYPE;
+            property.data = QueryRequest;
+            property.getResponseType = () => QueryResponse;
+            (0, class_injector_1.markExecutable)(target, propertyKey, property.name);
+        };
+    };
+};
+exports.createQuery = createQuery;
+const directPath = (path) => {
+    return {
+        type: 'direct',
+        ...path
+    };
+};
+exports.directPath = directPath;
+const indirectPath = (path) => {
+    return {
+        type: 'indirect',
+        ...path
+    };
+};
+exports.indirectPath = indirectPath;

package/query/functions/describe-query-filter.d.ts

@@ -0,0 +1,7 @@
+import { Instantiable } from "@rockster/common";
+import { Query } from "../interfaces/query";
+import { PendingAction } from "../../core";
+export declare const describeQueryFilter: <Entity>(pendingAction: PendingAction, target: Instantiable, query: Query<Entity>, select: string[]) => {
+    translated: string;
+    parameters: Record<string, any>;
+};

package/query/functions/describe-query-filter.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeQueryFilter = void 0;
+const common_1 = require("@rockster/common");
+const class_pipe_1 = require("@rockster/class-pipe");
+const validator_1 = __importDefault(require("validator"));
+const validOperators = {
+    like: true,
+    ilike: true,
+    '=': true,
+    '>=': true,
+    '<=': true,
+    '>': true,
+    '<': true,
+    '<>': true,
+    'is': true,
+    contains: true,
+    in: true,
+    between: true
+};
+const negatableOperators = {
+    like: true,
+    ilike: true,
+    contains: true,
+    in: true,
+    between: true
+};
+const validIsValues = {
+    'null': true,
+    'false': true,
+    'true': true,
+    'unknown': true
+};
+const describeQueryFilter = (pendingAction, target, query, select) => {
+    const parameters = {};
+    let paramIndex = 1;
+    let filter = query.filter.trim();
+    let lastField;
+    let expect = 'field';
+    let current = '';
+    let translated = '';
+    let isCollectingInValues = false;
+    let inValues = [];
+    let operator = '';
+    let isNegation = false;
+    const object = core.storage.findObject(target);
+    const properties = object.properties;
+    const requestRef = pendingAction.requestRef;
+    validateParentheses(filter, requestRef);
+    const nextParam = (value) => {
+        const key = `param${paramIndex++}`;
+        parameters[key] = value;
+        return `:${key}`;
+    };
+    const validate = () => {
+        if (!current)
+            return;
+        switch (expect) {
+            case 'andOr': {
+                const andOr = current.toLowerCase();
+                if (andOr !== 'and' && andOr !== 'or') {
+                    throw new common_1.BadRequestError({ message: `${requestRef} [filter] invalidCondition [${current}]` });
+                }
+                translated += ` ${andOr} `;
+                expect = 'field';
+                break;
+            }
+            case 'field': {
+                expect = 'operator';
+                const [_, name, jsonb] = current.split('.');
+                const [embeddedProperty, embeddedCast] = (jsonb || '').split('::');
+                const isValidProperty = properties[current];
+                if (!isValidProperty) {
+                    throw new common_1.BadRequestError({ message: `${requestRef} [filter] invalidField [${current}]` });
+                }
+                const fieldName = `${isValidProperty.path.entityAlias}.${isValidProperty.columnName}`;
+                select.pushIfNotExists(current);
+                lastField = {
+                    property: isValidProperty,
+                    name: fieldName,
+                    type: isValidProperty.type
+                };
+                current = fieldName;
+                if (isValidProperty.type === class_pipe_1.PropertyType.object && jsonb) {
+                    current += ` ->> '${embeddedProperty}'`;
+                    if (embeddedCast === 'boolean')
+                        lastField.type = class_pipe_1.PropertyType.boolean;
+                    else if (embeddedCast === 'date')
+                        lastField.type = class_pipe_1.PropertyType.date;
+                    else if (embeddedCast === 'number')
+                        lastField.type = class_pipe_1.PropertyType.numeric;
+                    else
+                        lastField.type = class_pipe_1.PropertyType.string;
+                }
+                translated += current;
+                break;
+            }
+            case 'operator': {
+                const lower = current.toLowerCase();
+                if (lower === 'not') {
+                    isNegation = true;
+                    break;
+                }
+                operator = lower;
+                if (!validOperators[operator]) {
+                    throw new common_1.BadRequestError({ message: `${requestRef} [filter] invalidOperator [${current}]` });
+                }
+                if (isNegation && !negatableOperators[operator]) {
+                    throw new common_1.BadRequestError({ message: `${requestRef} [filter] invalid use of NOT with operator [${operator}]` });
+                }
+                const prefix = isNegation ? 'NOT ' : '';
+                if (operator === 'contains') {
+                    translated += ` ${prefix}@>`;
+                    expect = 'value';
+                }
+                else if (operator === 'is') {
+                    translated += ` IS${isNegation ? ' NOT' : ''}`;
+                    expect = 'isValue';
+                }
+                else if (operator === 'between') {
+                    translated += ` ${prefix}BETWEEN`;
+                    expect = 'betweenValue';
+                }
+                else if (operator === 'in') {
+                    translated += ` ${prefix}IN`;
+                    expect = 'inValue';
+                }
+                else {
+                    translated += ` ${prefix}${operator}`;
+                    expect = 'value';
+                }
+                isNegation = false;
+                break;
+            }
+            case 'value': {
+                const value = checkFieldValue(requestRef, lastField, current);
+                translated += ` ${nextParam(value)}`;
+                expect = 'andOr';
+                break;
+            }
+            case 'isValue': {
+                const value = current.toLowerCase();
+                if (!validIsValues[value]) {
+                    throw new common_1.BadRequestError({ message: `${requestRef} [filter] invalidValue [${current}]` });
+                }
+                translated += ` ${value}`;
+                expect = 'andOr';
+                break;
+            }
+            case 'betweenValue': {
+                const parts = current.split(/\s+and\s+/i);
+                if (parts.length !== 2) {
+                    throw new common_1.BadRequestError({ message: `${requestRef} [filter] invalid BETWEEN syntax [${current}]` });
+                }
+                const start = checkFieldValue(requestRef, lastField, parts[0].trim());
+                const end = checkFieldValue(requestRef, lastField, parts[1].trim());
+                translated += ` ${nextParam(start)} AND ${nextParam(end)}`;
+                expect = 'andOr';
+                break;
+            }
+        }
+        current = '';
+    };
+    for (let i = 0; i < filter.length; i++) {
+        const letter = filter[i];
+        if (isCollectingInValues) {
+            if (letter === ')') {
+                if (current) {
+                    inValues.push(current.trim());
+                    current = '';
+                }
+                translated += ` (${inValues.map(val => {
+                    const parsed = checkFieldValue(requestRef, lastField, `'${val.replace(/'/g, '')}'`);
+                    return nextParam(parsed);
+                }).join(', ')})`;
+                expect = 'andOr';
+                isCollectingInValues = false;
+                inValues = [];
+                continue;
+            }
+            if (letter === ',') {
+                if (current) {
+                    inValues.push(current.trim());
+                    current = '';
+                }
+                continue;
+            }
+            if (letter === ' ') {
+                if (current.startsWith("'") && !current.endsWith("'")) {
+                    current += letter;
+                }
+                continue;
+            }
+            current += letter;
+            continue;
+        }
+        switch (letter) {
+            case '(': {
+                if (expect === 'inValue') {
+                    isCollectingInValues = true;
+                    continue;
+                }
+                validate();
+                translated += letter;
+                break;
+            }
+            case ')': {
+                validate();
+                translated += letter;
+                break;
+            }
+            case ',': {
+                current += letter;
+                break;
+            }
+            case ' ': {
+                if (current.startsWith("'") && !current.endsWith("'")) {
+                    current += letter;
+                }
+                else {
+                    validate();
+                }
+                break;
+            }
+            default: {
+                current += letter;
+                break;
+            }
+        }
+    }
+    if (current && !isCollectingInValues) {
+        validate();
+    }
+    return { translated, parameters };
+};
+exports.describeQueryFilter = describeQueryFilter;
+function checkFieldValue(requestRef, field, value) {
+    const type = field.type;
+    const invalidValueError = new common_1.BadRequestError({
+        message: `${requestRef} [filter] invalidValue [${value}] for field [${field.name}]`
+    });
+    if (field.property.isArray)
+        return value;
+    switch (type) {
+        case class_pipe_1.PropertyType.date: {
+            const isDate = value.startsWith("'") && value.endsWith("'") && !isNaN(Date.parse(value.replace(/'/g, '')));
+            if (value !== 'null' && !isDate)
+                throw invalidValueError;
+            break;
+        }
+        case class_pipe_1.PropertyType.string: {
+            const isString = value.startsWith("'") && value.endsWith("'");
+            if (value !== 'null' && !isString)
+                throw invalidValueError;
+            if (field.property.isUUID) {
+                const toCheckValue = value.replace(/'/g, '');
+                if (!validator_1.default.isUUID(toCheckValue))
+                    throw invalidValueError;
+            }
+            break;
+        }
+        case class_pipe_1.PropertyType.numeric:
+        case class_pipe_1.PropertyType.integer: {
+            const number = Number(value.replace(/'/g, ''));
+            if (isNaN(number))
+                throw invalidValueError;
+            return number.toString();
+        }
+        case class_pipe_1.PropertyType.boolean: {
+            const isBoolean = ['true', 'false', 'unknown', 'null'].includes(value.toLowerCase());
+            if (!isBoolean)
+                throw invalidValueError;
+            break;
+        }
+        default:
+            throw new common_1.BadRequestError({ message: `${requestRef} [filter] invalidField [${field.name}]` });
+    }
+    return value.replace(/'/g, '');
+}
+;
+function validateParentheses(filter, requestRef) {
+    let count = 0;
+    for (let i = 0; i < filter.length; i++) {
+        const ch = filter[i];
+        if (ch === '(')
+            count++;
+        else if (ch === ')') {
+            if (count === 0)
+                throw new common_1.BadRequestError({ message: `${requestRef} [filter] unexpected closing parenthesis at position ${i}` });
+            count--;
+        }
+    }
+    if (count !== 0)
+        throw new common_1.BadRequestError({ message: `${requestRef} [filter] missing closing parenthesis` });
+}

package/query/functions/execute-query.d.ts

@@ -0,0 +1,11 @@
+import { SelectQueryBuilder } from "../../database";
+import { IQueryContent, Query } from "../interfaces/query";
+export type QueryInterceptHandle<Entity> = {
+    (queryBuilder: SelectQueryBuilder<Entity>): Promise<SelectQueryBuilder<Entity>> | SelectQueryBuilder<Entity>;
+};
+export type ExecureQueryOptions<Entity> = {
+    content: IQueryContent<Entity>;
+    preFilter?: string;
+    intercept?: QueryInterceptHandle<Entity>;
+};
+export declare const executeQuery: <Entity>({ content: queryContent, intercept, preFilter }: ExecureQueryOptions<Entity>) => Promise<Query<Entity>>;

package/query/functions/execute-query.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeQuery = void 0;
+const create_query_builder_1 = require("./create-query-builder");
+const class_pipe_1 = require("@rockster/class-pipe");
+const logger_1 = require("@rockster/logger");
+const global_1 = require("../../global");
+const executeQuery = async ({ content: queryContent, intercept, preFilter }) => {
+    const logger = new logger_1.Logger('ExecuteQuery');
+    const query = queryContent.query;
+    const queryBuilder = await (0, create_query_builder_1.createQueryBuilder)(queryContent, intercept);
+    let page = queryContent.query.page;
+    let getWhere = 'where';
+    let filtered = 0;
+    let total;
+    const object = core
+        .storage
+        .findObject(queryContent.target);
+    if (preFilter) {
+        queryBuilder.where(preFilter);
+        getWhere = 'andWhere';
+    }
+    if (page) {
+        total = await queryBuilder.getCount();
+        queryBuilder.take(query.take);
+        queryBuilder.skip(query.skip);
+    }
+    if (query.filter) {
+        queryBuilder[getWhere](query.filter, queryContent.parameters);
+        filtered = await queryBuilder.getCount();
+    }
+    if (query.orderBy) {
+        query.orderBy.forEach((orderBy, i) => {
+            const direction = orderBy.direction.toUpperCase();
+            if (i === 0) {
+                queryBuilder.orderBy(orderBy.property, direction);
+            }
+            else {
+                queryBuilder.addOrderBy(orderBy.property, direction);
+            }
+        });
+    }
+    queryBuilder.select(queryContent.naviteSelect);
+    queryBuilder.getVirtualSelect().forEach((virtualSelect) => {
+        queryBuilder.addSelect(virtualSelect.selection, virtualSelect.alias);
+    });
+    logger.debug(queryBuilder.getSql());
+    const items = await queryBuilder.getMany();
+    const data = await Promise.all(items.map((item) => {
+        return (0, class_pipe_1.transform)({
+            target: object.rootPath.target(),
+            values: item,
+            select: query.select,
+            fullPath: `${queryContent.rootAlias}.`,
+            groups: [global_1.actionGroups.query]
+        });
+    }));
+    return {
+        skip: page
+            ? query.skip
+            : undefined,
+        take: page
+            ? query.take
+            : undefined,
+        total: page
+            ? total
+            : undefined,
+        filtered: query.filter
+            ? filtered
+            : undefined,
+        data: data
+    };
+};
+exports.executeQuery = executeQuery;

package/query/functions/get-column-path.d.ts

@@ -0,0 +1,2 @@
+import { QueryPath } from "../interfaces/query";
+export declare const getColumnPath: (path: QueryPath, currentPath?: string) => string;

package/query/functions/get-column-path.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnPath = void 0;
+const getColumnPath = (path, currentPath = '') => {
+    let fullPath = '';
+    if (path.type === 'embedded') {
+        fullPath = (0, exports.getColumnPath)(path.parent, path.alias);
+    }
+    else {
+        fullPath = `${path.alias}.${currentPath}`;
+    }
+    return fullPath;
+};
+exports.getColumnPath = getColumnPath;

package/query/functions/get-native-select.d.ts

@@ -0,0 +1,2 @@
+import { Instantiable } from "@rockster/common";
+export declare const getNativeSelect: (target: Instantiable, select: string[]) => string[];

package/query/functions/get-native-select.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeSelect = void 0;
+const map_query_property_to_column_name_1 = require("./map-query-property-to-column-name");
+const getNativeSelect = (target, select) => {
+    const queryObject = core.storage.findObject(target);
+    return select.map(item => (0, map_query_property_to_column_name_1.mapQueryPropertyToColumnName)(queryObject, item));
+};
+exports.getNativeSelect = getNativeSelect;

package/query/functions/load-properties.d.ts

@@ -0,0 +1,19 @@
+import { Dictionary, Instantiable } from "@rockster/common";
+import { Paths } from "../../database/interfaces/path";
+import { QueryPath, QueryProperty, QueryPropertyType, QueryRelationConfig } from "../interfaces/query";
+export type LoadPropertiesArgs = {
+    type: QueryPropertyType;
+    target: Instantiable;
+    alias: string;
+    entityAlias?: string;
+    properties: Dictionary<QueryProperty>;
+    fullPath?: string;
+    relation?: QueryRelationConfig;
+    paths?: Paths<any>;
+    parent?: QueryPath;
+    secure?: boolean;
+    initializedObjects?: string[];
+    rootEntity: Instantiable;
+    rootFullPath?: string;
+};
+export declare const loadProperties: ({ type, target, alias, entityAlias, properties, parent, paths, relation, fullPath, secure, initializedObjects, rootEntity, rootFullPath }: LoadPropertiesArgs) => void;