@sqb/connect 4.12.0 → 4.13.0

package/esm/index.js

@@ -1,23 +1,12 @@
 import 'reflect-metadata';
-export * from './client/types.js';
 export * from './client/adapter.js';
+export * from './client/cursor.js';
+export * from './client/extensions.js';
 export * from './client/sqb-client.js';
 export * from './client/sqb-connection.js';
-export * from './client/cursor.js';
-export { registerAdapter, unRegisterAdapter } from './client/extensions.js';
-export * from './orm/orm.type.js';
-export * from './orm/orm.const.js';
+export * from './client/types.js';
+export * from './orm/backward.js';
 export * from './orm/base-entity.js';
-export * from './orm/repository.class.js';
-export * from './orm/model/entity-metadata.js';
-export * from './orm/model/field-metadata.js';
-export * from './orm/model/column-field-metadata.js';
-export * from './orm/model/embedded-field-metadata.js';
-export * from './orm/model/association-field-metadata.js';
-export * from './orm/model/association.js';
-export * from './orm/model/association-node.js';
-export * from './orm/model/index-metadata.js';
-export * from './orm/model/link-chain.js';
 export * from './orm/decorators/column.decorator.js';
 export * from './orm/decorators/embedded.decorator.js';
 export * from './orm/decorators/entity.decorator.js';
@@ -27,5 +16,17 @@ export * from './orm/decorators/index.decorator.js';
 export * from './orm/decorators/link.decorator.js';
 export * from './orm/decorators/primarykey.decorator.js';
 export * from './orm/decorators/transform.decorator.js';
-export { isColumnField, isEmbeddedField, isAssociationField, isEntityClass } from './orm/util/orm.helper.js';
-export * from './orm/backward.js';
+export * from './orm/model/association.js';
+export * from './orm/model/association-field-metadata.js';
+export * from './orm/model/association-node.js';
+export * from './orm/model/column-field-metadata.js';
+export * from './orm/model/embedded-field-metadata.js';
+export * from './orm/model/entity-metadata.js';
+export * from './orm/model/field-metadata.js';
+export * from './orm/model/index-metadata.js';
+export * from './orm/model/link-chain.js';
+export * from './orm/orm.const.js';
+export * from './orm/orm.type.js';
+export * from './orm/repository.class.js';
+export { isAssociationField, isColumnField, isEmbeddedField, isEntityClass } from './orm/util/orm.helper.js';
+export * from './orm/util/parse-fields-projection.js';

package/esm/orm/commands/command.helper.js

@@ -1,4 +1,4 @@
-import { And, Eq, Exists, Field, InnerJoin, isCompOperator, isLogicalOperator, LeftOuterJoin, Raw, Select, } from '@sqb/builder';
+import { And, Eq, Exists, Field, InnerJoin, isCompOperator, isLogicalOperator, LeftOuterJoin, op, OperatorType, Raw, Select, } from '@sqb/builder';
 import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
 import { isAssociationField, isColumnField, isEmbeddedField } from '../util/orm.helper.js';
@@ -47,7 +47,7 @@ export async function joinAssociation(joinInfos, association, parentAlias, inner
 }
 export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T') {
     let srcOp;
-    if (isLogicalOperator(filter))
+    if (isLogicalOperator(filter) && filter._operatorType === trgOp._operatorType)
         srcOp = filter;
     else {
         srcOp = And();
@@ -56,6 +56,7 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
         else
             srcOp.add(filter);
     }
+    const associationPathCache = {};
     for (const item of srcOp._items) {
         if (isLogicalOperator(item)) {
             const ctor = Object.getPrototypeOf(item).constructor;
@@ -74,19 +75,34 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
                 let _curPrefix = '';
                 let _curSuffix = '';
                 let subSelect;
-                for (let i = 0; i < l; i++) {
+                let currentOp = trgOp;
+                let i = 0;
+                const parentPath = itemPath
+                    .slice(0, l - 2)
+                    .join('.')
+                    .toLowerCase();
+                const cached = associationPathCache[parentPath];
+                if (cached) {
+                    /** Jump to last item */
+                    i = l - 1;
+                    _curEntity = cached._curEntity;
+                    _curAlias = cached._curAlias;
+                    currentOp = cached.currentOp;
+                }
+                for (i; i < l; i++) {
                     pt = itemPath[i];
                     const col = EntityMetadata.getField(_curEntity, pt);
                     if (!col)
                         throw new Error(`Unknown property (${item._left}) defined in filter`);
-                    // if last item on path
+                    /** if last item on path */
                     if (i === l - 1) {
                         if (!isColumnField(col))
                             throw new Error(`Invalid column expression (${item._left}) defined in filter`);
                         const ctor = Object.getPrototypeOf(item).constructor;
-                        trgOp.add(new ctor(Field(_curAlias + '.' + _curPrefix + col.fieldName + _curSuffix, col.dataType, col.isArray), item._right));
+                        currentOp.add(new ctor(Field(_curAlias + '.' + _curPrefix + col.fieldName + _curSuffix, col.dataType, col.isArray), item._right));
                     }
                     else {
+                        /** if not last item on path */
                         if (isColumnField(col))
                             throw new Error(`Invalid column (${item._left}) defined in filter`);
                         if (isEmbeddedField(col)) {
@@ -104,8 +120,13 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
                             const targetCol = await col.association.resolveTargetProperty();
                             subSelect = Select(Raw('1')).from(_curEntity.tableName + ' K');
                             subSelect.where(Eq(Field('K.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), Field(tableAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
-                            trgOp.add(Exists(subSelect));
-                            trgOp = subSelect._where;
+                            currentOp.add(Exists(subSelect));
+                            if (currentOp._operatorType !== OperatorType.and) {
+                                currentOp = op.or();
+                                subSelect.where(currentOp);
+                            }
+                            else
+                                currentOp = subSelect._where;
                             if (col.association.conditions) {
                                 await prepareFilter(_curEntity, col.association.conditions, trgOp, 'K');
                             }
@@ -124,6 +145,14 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
                             _curAlias = joinAlias;
                             node = node.next;
                         }
+                        /** If next path is the last one */
+                        if (i === l - 2) {
+                            associationPathCache[parentPath] = {
+                                _curEntity,
+                                _curAlias,
+                                currentOp,
+                            };
+                        }
                     }
                 }
                 continue;

package/esm/orm/commands/create.command.js

@@ -60,8 +60,9 @@ export class CreateCommand {
                 if (typeof col.serialize === 'function')
                     v = col.serialize(v, col.name);
                 if (v == null) {
-                    if (col.notNull && !col.autoGenerated)
+                    if (col.notNull && !col.autoGenerated) {
                         throw new Error(`${entity.name}.${col.name} is required and can't be null`);
+                    }
                     continue;
                 }
                 ColumnFieldMetadata.checkEnumValue(col, v);

package/esm/orm/commands/find.command.js

@@ -1,9 +1,9 @@
 import { And, In, Param, Select } from '@sqb/builder';
-import { Entity } from '../decorators/entity.decorator.js';
 import { AssociationNode } from '../model/association-node.js';
 import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
 import { isAssociationField, isColumnField, isEmbeddedField } from '../util/orm.helper.js';
+import { parseFieldsProjection } from '../util/parse-fields-projection.js';
 import { joinAssociationGetLast, prepareFilter } from './command.helper.js';
 import { RowConverter } from './row-converter.js';
 const SORT_ORDER_PATTERN = /^([-+])?(.*)$/;
@@ -53,9 +53,7 @@ export class FindCommand {
             maxEagerFetch: args.maxEagerFetch,
         });
         await command.addFields({
-            pick: args.pick,
-            include: args.include,
-            omit: args.omit,
+            projection: args.projection,
             sort: args.sort,
         });
         if (args.filter)
@@ -68,22 +66,10 @@ export class FindCommand {
         const tableAlias = opts.tableAlias || this.resultAlias;
         const entity = opts.entity || this._getEntityFromAlias(tableAlias);
         const converter = opts.converter || this.converter;
-        const _pick = opts.pick ? opts.pick.map(x => x.toLowerCase()) : undefined;
-        const _omit = opts.omit ? opts.omit.map(x => x.toLowerCase()) : undefined;
-        const _include = opts.include ? opts.include.map(x => x.toLowerCase()) : undefined;
-        let requestedFields;
-        if (_pick)
-            requestedFields = [..._pick];
-        else {
-            requestedFields = Entity.getFieldNames(entity.ctor).reduce((a, x) => {
-                const f = Entity.getField(entity.ctor, x);
-                if (f && !f.exclusive)
-                    a.push(x.toLowerCase());
-                return a;
-            }, []);
-        }
-        if (_include)
-            requestedFields.push(..._include);
+        const projection = typeof opts.projection === 'string' || Array.isArray(opts.projection)
+            ? parseFieldsProjection(opts.projection)
+            : opts.projection;
+        const defaultFields = !projection || !Object.values(projection).find(p => !p.sign);
         const sortFields = opts.sort && opts.sort.length ? opts.sort.map(x => x.toLowerCase()) : undefined;
         const prefix = opts.prefix || '';
         const suffix = opts.suffix || '';
@@ -92,12 +78,16 @@ export class FindCommand {
             if (!col || col.hidden)
                 continue;
             const colNameLower = col.name.toLowerCase();
-            // Ignore field if in excluded list
-            if (_omit && _omit.includes(colNameLower))
-                continue;
-            // Check if field request list
-            if (!requestedFields.find((x) => x === colNameLower || x.startsWith(colNameLower + '.')))
+            const p = projection?.[colNameLower];
+            if (
+            /** Ignore if field is omitted */
+            p?.sign === '-' ||
+                /** Ignore if default fields and field is not in projection */
+                (!defaultFields && !p) ||
+                /** Ignore if default fields enabled and fields is exclusive */
+                (defaultFields && col.exclusive && !p)) {
                 continue;
+            }
             // Add field to select list if field is a column
             if (isColumnField(col)) {
                 const fieldAlias = this._selectColumn(tableAlias, col, prefix, suffix);
@@ -122,9 +112,7 @@ export class FindCommand {
                     entity: typ,
                     prefix: col.fieldNamePrefix,
                     suffix: col.fieldNameSuffix,
-                    pick: _pick?.includes(colNameLower) ? undefined : extractSubFields(colNameLower, _pick),
-                    include: extractSubFields(colNameLower, _include),
-                    omit: extractSubFields(colNameLower, _omit),
+                    projection: p?.projection,
                     sort: extractSubFields(colNameLower, sortFields),
                 });
                 continue;
@@ -142,9 +130,7 @@ export class FindCommand {
                         tableAlias: joinInfo.joinAlias,
                         converter: subConverter,
                         entity: joinInfo.targetEntity,
-                        pick: _pick?.includes(colNameLower) ? undefined : extractSubFields(colNameLower, _pick),
-                        include: extractSubFields(colNameLower, _include),
-                        omit: extractSubFields(colNameLower, _omit),
+                        projection: p?.projection,
                         sort: extractSubFields(colNameLower, sortFields),
                     });
                     continue;
@@ -164,9 +150,7 @@ export class FindCommand {
                     await findCommand.filter(In(targetCol.name, Param(parentField)));
                     const sort = sortFields && extractSubFields(colNameLower, sortFields);
                     await findCommand.addFields({
-                        pick: _pick?.includes(colNameLower) ? undefined : extractSubFields(colNameLower, _pick),
-                        include: extractSubFields(colNameLower, _include),
-                        omit: extractSubFields(colNameLower, _omit),
+                        projection: p?.projection,
                         sort,
                     });
                     if (sort)
@@ -260,16 +244,18 @@ export class FindCommand {
         if (args.offset)
             query.offset(args.offset);
         // joins must be added last
-        if (this._joins)
+        if (this._joins) {
             for (const j of this._joins) {
                 query.join(j.join);
             }
+        }
         // Execute query
         const resp = await args.connection.execute(query, {
             params: args?.params,
             fetchRows: args?.limit,
             objectRows: false,
             cursor: false,
+            prettyPrint: args.prettyPrint,
         });
         // Create objects
         if (resp.rows && resp.fields) {

package/esm/orm/commands/row-converter.js

@@ -1,13 +1,7 @@
 import { DataType } from '@sqb/builder';
-const isValueProperty = (prop) => {
-    return prop.fieldAlias && !prop.converter;
-};
-const isObjectProperty = (prop) => {
-    return prop.converter && !prop.findCommand;
-};
-const isNestedProperty = (prop) => {
-    return prop.converter && prop.findCommand;
-};
+const isValueProperty = (prop) => prop.fieldAlias && !prop.converter;
+const isObjectProperty = (prop) => prop.converter && !prop.findCommand;
+const isNestedProperty = (prop) => prop.converter && prop.findCommand;
 export class RowConverter {
     constructor(resultType, parent) {
         this.resultType = resultType;
@@ -150,8 +144,9 @@ export class RowConverter {
                             }
                         },
                     });
-                    if (r.length > findCommand.maxEagerFetch)
+                    if (r.length > findCommand.maxEagerFetch) {
                         throw new Error(`Number of returning rows for "${propKey}" exceeds maxEagerFetch limit`);
+                    }
                     for (let i = 0; i < result.length; i++) {
                         const row = rows[i];
                         let obj = result[i];

package/esm/orm/decorators/column.decorator.js

@@ -1,5 +1,9 @@
 import { EntityMetadata } from '../model/entity-metadata.js';
+import { DECORATOR_FACTORY } from '../orm.const.js';
 export function Column(arg0) {
+    return Column[DECORATOR_FACTORY](arg0);
+}
+Column[DECORATOR_FACTORY] = function (arg0) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('Symbol properties are not accepted');
@@ -16,4 +20,4 @@ export function Column(arg0) {
         }
         EntityMetadata.defineColumnField(entity, propertyKey, options);
     };
-}
+};

package/esm/orm/decorators/link.decorator.js

@@ -8,16 +8,19 @@ export function Link(options) {
             throw new TypeError('Symbol properties are not allowed');
         const reflectType = Reflect.getMetadata('design:type', target, propertyKey);
         if (!root) {
-            if (reflectType === Array)
+            if (reflectType === Array) {
                 throw new TypeError(`Can't get type information while it is an array. Please define entity type`);
+            }
             if (!EntityMetadata.get(reflectType))
                 throw new TypeError(`No entity metadata found for type "${reflectType}"`);
             fn.toOne(reflectType);
         }
-        if (reflectType !== Array && root.first.returnsMany())
+        if (reflectType !== Array && root.first.returnsMany()) {
             throw new TypeError(`Link returns single instance however property type is an array`);
-        if (reflectType === Array && !root.first.returnsMany())
+        }
+        if (reflectType === Array && !root.first.returnsMany()) {
             throw new TypeError(`Link returns array of instances however property type is not an array`);
+        }
         const entity = EntityMetadata.define(target.constructor);
         // @ts-ignore
         // noinspection JSConstantReassignment

package/esm/orm/decorators/primarykey.decorator.js

@@ -3,8 +3,9 @@ import { Column } from './column.decorator.js';
 export function PrimaryKey(arg0, arg1) {
     return function (target, propertyKey) {
         if (arguments.length === 1) {
-            if (!(typeof arg0 === 'string' || Array.isArray(arg0)))
+            if (!(typeof arg0 === 'string' || Array.isArray(arg0))) {
                 throw new Error(`You must specify primary index column(s)`);
+            }
             const meta = EntityMetadata.define(target);
             EntityMetadata.setPrimaryKeys(meta, arg0, arg1);
             return;

package/esm/orm/model/association.js

@@ -63,17 +63,15 @@ export class Association {
                 this._targetProperty = foreign._targetProperty;
                 return;
             }
-            else {
-                // Try to determine key fields from foreign key from target to source
-                foreign = await EntityMetadata.getForeignKeyFor(target, source);
-                if (foreign && foreign !== this) {
-                    await foreign._resolveKeys();
-                    this._sourceKey = foreign._targetKey;
-                    this._sourceProperty = foreign._targetProperty;
-                    this._targetKey = foreign._sourceKey;
-                    this._targetProperty = foreign._sourceProperty;
-                    return;
-                }
+            // Try to determine key fields from foreign key from target to source
+            foreign = await EntityMetadata.getForeignKeyFor(target, source);
+            if (foreign && foreign !== this) {
+                await foreign._resolveKeys();
+                this._sourceKey = foreign._targetKey;
+                this._sourceProperty = foreign._targetProperty;
+                this._targetKey = foreign._sourceKey;
+                this._targetProperty = foreign._sourceProperty;
+                return;
             }
             if (this.many) {
                 if (!sourceKey) {

package/esm/orm/model/entity-metadata.js

@@ -56,8 +56,9 @@ export var EntityMetadata;
     EntityMetadata.getEmbeddedField = getEmbeddedField;
     function getAssociationField(entity, fieldName) {
         const el = getField(entity, fieldName);
-        if (el && !isAssociationField(el))
+        if (el && !isAssociationField(el)) {
             throw new Error(`"${el.name}" requested as "association" but it is "${el.kind}"`);
+        }
         return el;
     }
     EntityMetadata.getAssociationField = getAssociationField;
@@ -85,13 +86,14 @@ export var EntityMetadata;
             return out;
         }
         // Create a cached name array
-        if (!Object.prototype.hasOwnProperty.call(entity, '_fieldNames'))
+        if (!Object.prototype.hasOwnProperty.call(entity, '_fieldNames')) {
             Object.defineProperty(entity, '_fieldNames', {
                 enumerable: false,
                 configurable: true,
                 writable: true,
                 value: Object.values(entity.fields).map(m => m.name),
             });
+        }
         return entity._fieldNames;
     }
     EntityMetadata.getFieldNames = getFieldNames;

package/esm/orm/orm.const.js

@@ -1,2 +1,3 @@
 export const ENTITY_METADATA_KEY = Symbol.for('SQB_ENTITY_METADATA');
 export const REPOSITORY_KEY = Symbol.for('SQB_REPOSITORY');
+export const DECORATOR_FACTORY = Symbol.for('decorator.factory');

package/esm/orm/repository.class.js

@@ -34,46 +34,31 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         }, options);
     }
     exists(keyValue, options) {
-        return this._execute(async (connection) => {
-            return this._exists(keyValue, { ...options, connection });
-        }, options);
+        return this._execute(async (connection) => this._exists(keyValue, { ...options, connection }), options);
     }
-    count(options) {
-        return this._execute(async (connection) => {
-            return this._count({ ...options, connection });
-        }, options);
+    existsOne(options) {
+        return this._execute(async (connection) => this._existsOne({ ...options, connection }), options);
     }
-    /** @deprecated - Use findById instead */
-    find(keyValue, options) {
-        return this.findById(keyValue, options);
+    count(options) {
+        return this._execute(async (connection) => this._count({ ...options, connection }), options);
     }
     findById(keyValue, options) {
-        return this._execute(async (connection) => {
-            return this._find(keyValue, { ...options, connection });
-        }, options);
+        return this._execute(async (connection) => this._find(keyValue, { ...options, connection }), options);
     }
     findOne(options) {
-        return this._execute(async (connection) => {
-            return await this._findOne({
-                ...options,
-                connection,
-            });
-        }, options);
+        return this._execute(async (connection) => await this._findOne({
+            ...options,
+            connection,
+        }), options);
     }
     findMany(options) {
-        return this._execute(async (connection) => {
-            return this._findMany({ ...options, connection });
-        }, options);
+        return this._execute(async (connection) => this._findMany({ ...options, connection }), options);
     }
     delete(keyValue, options) {
-        return this._execute(async (connection) => {
-            return this._delete(keyValue, { ...options, connection });
-        }, options);
+        return this._execute(async (connection) => this._delete(keyValue, { ...options, connection }), options);
     }
     deleteMany(options) {
-        return this._execute(async (connection) => {
-            return this._deleteMany({ ...options, connection });
-        }, options);
+        return this._execute(async (connection) => this._deleteMany({ ...options, connection }), options);
     }
     update(keyValue, values, options) {
         return this._execute(async (connection) => {
@@ -84,14 +69,10 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         }, options);
     }
     updateOnly(keyValue, values, options) {
-        return this._execute(async (connection) => {
-            return !!(await this._update(keyValue, values, { ...options, connection }));
-        }, options);
+        return this._execute(async (connection) => !!(await this._update(keyValue, values, { ...options, connection })), options);
     }
     updateMany(values, options) {
-        return this._execute(async (connection) => {
-            return this._updateMany(values, { ...options, connection });
-        });
+        return this._execute(async (connection) => this._updateMany(values, { ...options, connection }));
     }
     async _execute(fn, opts) {
         let connection = opts?.connection;
@@ -129,11 +110,25 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             else
                 filter.push(options.filter);
         }
-        return !!(await CountCommand.execute({
+        return this._existsOne({
+            ...options,
+            filter,
+        });
+    }
+    async _existsOne(options) {
+        const filter = [];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        const resp = await FindCommand.execute({
             ...options,
             filter,
             entity: this._entity,
-        }));
+        });
+        return resp.length > 0;
     }
     async _count(options) {
         return CountCommand.execute({

package/esm/orm/util/apply-mixins.js

@@ -4,8 +4,9 @@ export function applyMixins(derivedCtor, baseCtor, filter) {
             name === '__proto__' ||
             name === 'toJSON' ||
             name === 'toString' ||
-            (filter && !filter(name)))
+            (filter && !filter(name))) {
             continue;
+        }
         Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));
     }
 }

package/esm/orm/util/extract-keyvalues.js

@@ -8,14 +8,16 @@ export function extractKeyValues(entityDef, valueOrInstance, keepOther) {
         const col = EntityMetadata.getField(entityDef, k);
         if (!col)
             throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);
-        if (!isColumnField(col))
+        if (!isColumnField(col)) {
             throw new Error(`Column (${k}) defined as primary key in entity "${entityDef.name}" is not a data column`);
+        }
     };
     // if entity's primary key has more than one key field
     if (primaryIndex.columns.length > 1) {
-        if (typeof valueOrInstance !== 'object')
+        if (typeof valueOrInstance !== 'object') {
             throw new Error(`"${entityDef.name}" entity` +
                 ` has more than one primary key field and you must provide all values with an key/value pair`);
+        }
         const valueKeys = Object.keys(valueOrInstance);
         const valueKeysUpper = valueKeys.map(x => x.toUpperCase());
         const out = {};
@@ -41,8 +43,9 @@ export function extractKeyValues(entityDef, valueOrInstance, keepOther) {
         const valueKeys = Object.keys(valueOrInstance);
         const valueKeysUpper = valueKeys.map(x => x.toUpperCase());
         const k = valueKeysUpper.indexOf(primaryColumnName.toUpperCase());
-        if (k < 0)
+        if (k < 0) {
             throw new Error(`Value of key field "${entityDef.name}.${primaryColumnName}" required to perform this operation`);
+        }
         const out = { [primaryColumnName]: valueOrInstance[valueKeys[k]] };
         if (keepOther) {
             for (let i = 0; i < valueKeys.length; i++) {

package/esm/orm/util/orm.helper.js

@@ -8,12 +8,8 @@ export function isEntityClass(fn) {
 export function isColumnField(f) {
     return !!(f && f.name && f.kind === 'column');
 }
-export const isEmbeddedField = (f) => {
-    return !!(f && f.name && f.kind === 'object');
-};
-export const isAssociationField = (f) => {
-    return !!(f && f.name && f.kind === 'association');
-};
+export const isEmbeddedField = (f) => !!(f && f.name && f.kind === 'object');
+export const isAssociationField = (f) => !!(f && f.name && f.kind === 'association');
 export async function resolveEntity(ctorThunk) {
     if (typeof ctorThunk !== 'function')
         return;

package/esm/orm/util/parse-fields-projection.js

@@ -0,0 +1,59 @@
+import { splitString } from 'fast-tokenizer';
+const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
+const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
+export class FieldsProjection {
+}
+(function (FieldsProjection) {
+    class Item {
+    }
+    FieldsProjection.Item = Item;
+})(FieldsProjection || (FieldsProjection = {}));
+export function parseFieldsProjection(projection, keepCase) {
+    const arr = Array.isArray(projection) ? projection : [projection];
+    if (!(arr && arr.length))
+        return;
+    const out = new FieldsProjection();
+    for (let s of arr) {
+        if (!keepCase)
+            s = s.toLowerCase();
+        parse(s, out);
+    }
+    return out;
+}
+function parse(input, target) {
+    /** Add dot before brackets which is required to split fields */
+    input = input.replace(NO_DOT_BRACKET_PATTERN, s => s.charAt(0) + '.' + s.substring(1));
+    const fields = splitString(input, {
+        delimiters: '.',
+        brackets: true,
+        keepBrackets: false,
+    });
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (f.includes(',')) {
+            const subFields = splitString(f, {
+                delimiters: ',',
+                brackets: true,
+                keepBrackets: true,
+            });
+            for (const n of subFields) {
+                parse(n, target);
+            }
+            continue;
+        }
+        const m = FIELD_PATTERN.exec(f);
+        /* istanbul ignore next */
+        if (!m)
+            throw new TypeError(`Invalid field path (${input})`);
+        const fieldName = m[2];
+        const treeItem = (target[fieldName] = target[fieldName] || new FieldsProjection.Item());
+        if (m[1])
+            treeItem.sign = m[1];
+        if (i === fields.length - 1) {
+            delete treeItem.projection;
+        }
+        else {
+            target = treeItem.projection = treeItem.projection || new FieldsProjection();
+        }
+    }
+}