@sqb/connect 4.12.1 → 4.14.0

package/cjs/orm/model/association.js

@@ -66,17 +66,15 @@ class Association {
                 this._targetProperty = foreign._targetProperty;
                 return;
             }
-            else {
-                // Try to determine key fields from foreign key from target to source
-                foreign = await entity_metadata_js_1.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 entity_metadata_js_1.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/cjs/orm/model/entity-metadata.js

@@ -59,8 +59,9 @@ var EntityMetadata;
     EntityMetadata.getEmbeddedField = getEmbeddedField;
     function getAssociationField(entity, fieldName) {
         const el = getField(entity, fieldName);
-        if (el && !(0, orm_helper_js_1.isAssociationField)(el))
+        if (el && !(0, orm_helper_js_1.isAssociationField)(el)) {
             throw new Error(`"${el.name}" requested as "association" but it is "${el.kind}"`);
+        }
         return el;
     }
     EntityMetadata.getAssociationField = getAssociationField;
@@ -88,13 +89,14 @@ 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/cjs/orm/repository.class.js

@@ -37,47 +37,31 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
         }, 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);
     }
     existsOne(options) {
-        return this._execute(async (connection) => {
-            return this._existsOne({ ...options, connection });
-        }, options);
+        return this._execute(async (connection) => this._existsOne({ ...options, connection }), options);
     }
     count(options) {
-        return this._execute(async (connection) => {
-            return this._count({ ...options, connection });
-        }, 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) => {
@@ -88,14 +72,10 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
         }, 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;

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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyMixins = void 0;
+exports.applyMixins = applyMixins;
 function applyMixins(derivedCtor, baseCtor, filter) {
     for (const name of Object.getOwnPropertyNames(baseCtor.prototype)) {
         if (name === 'constructor' ||
             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));
     }
 }
-exports.applyMixins = applyMixins;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractKeyValues = void 0;
+exports.extractKeyValues = extractKeyValues;
 const entity_metadata_js_1 = require("../model/entity-metadata.js");
 const orm_helper_js_1 = require("./orm.helper.js");
 function extractKeyValues(entityDef, valueOrInstance, keepOther) {
@@ -11,14 +11,16 @@ function extractKeyValues(entityDef, valueOrInstance, keepOther) {
         const col = entity_metadata_js_1.EntityMetadata.getField(entityDef, k);
         if (!col)
             throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);
-        if (!(0, orm_helper_js_1.isColumnField)(col))
+        if (!(0, orm_helper_js_1.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 = {};
@@ -44,8 +46,9 @@ 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++) {
@@ -58,4 +61,3 @@ function extractKeyValues(entityDef, valueOrInstance, keepOther) {
     }
     return { [primaryColumnName]: valueOrInstance };
 }
-exports.extractKeyValues = extractKeyValues;

package/cjs/orm/util/orm.helper.js

@@ -1,26 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveEntityMeta = exports.resolveEntity = exports.isAssociationField = exports.isEmbeddedField = exports.isColumnField = exports.isEntityClass = exports.isClass = void 0;
+exports.isAssociationField = exports.isEmbeddedField = void 0;
+exports.isClass = isClass;
+exports.isEntityClass = isEntityClass;
+exports.isColumnField = isColumnField;
+exports.resolveEntity = resolveEntity;
+exports.resolveEntityMeta = resolveEntityMeta;
 const orm_const_js_1 = require("../orm.const.js");
 function isClass(fn) {
     return typeof fn === 'function' && /^\s*class/.test(fn.toString());
 }
-exports.isClass = isClass;
 function isEntityClass(fn) {
     return isClass(fn) && Reflect.hasMetadata(orm_const_js_1.ENTITY_METADATA_KEY, fn);
 }
-exports.isEntityClass = isEntityClass;
 function isColumnField(f) {
     return !!(f && f.name && f.kind === 'column');
 }
-exports.isColumnField = isColumnField;
-const isEmbeddedField = (f) => {
-    return !!(f && f.name && f.kind === 'object');
-};
+const isEmbeddedField = (f) => !!(f && f.name && f.kind === 'object');
 exports.isEmbeddedField = isEmbeddedField;
-const isAssociationField = (f) => {
-    return !!(f && f.name && f.kind === 'association');
-};
+const isAssociationField = (f) => !!(f && f.name && f.kind === 'association');
 exports.isAssociationField = isAssociationField;
 async function resolveEntity(ctorThunk) {
     if (typeof ctorThunk !== 'function')
@@ -30,9 +28,7 @@ async function resolveEntity(ctorThunk) {
     if (isEntityClass(ctorThunk))
         return ctorThunk;
 }
-exports.resolveEntity = resolveEntity;
 async function resolveEntityMeta(ctorThunk) {
     const ctor = await resolveEntity(ctorThunk);
     return ctor && Reflect.getMetadata(orm_const_js_1.ENTITY_METADATA_KEY, ctor);
 }
-exports.resolveEntityMeta = resolveEntityMeta;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFieldsProjection = exports.FieldsProjection = void 0;
+exports.FieldsProjection = void 0;
+exports.parseFieldsProjection = parseFieldsProjection;
 const fast_tokenizer_1 = require("fast-tokenizer");
 const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
 const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
@@ -24,12 +25,9 @@ function parseFieldsProjection(projection, keepCase) {
     }
     return out;
 }
-exports.parseFieldsProjection = parseFieldsProjection;
 function parse(input, target) {
     /** Add dot before brackets which is required to split fields */
-    input = input.replace(NO_DOT_BRACKET_PATTERN, s => {
-        return s.charAt(0) + '.' + s.substring(1);
-    });
+    input = input.replace(NO_DOT_BRACKET_PATTERN, s => s.charAt(0) + '.' + s.substring(1));
     const fields = (0, fast_tokenizer_1.splitString)(input, {
         delimiters: '.',
         brackets: true,

package/cjs/orm/util/serialize-field.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeColumn = void 0;
+exports.serializeColumn = serializeColumn;
 const builder_1 = require("@sqb/builder");
 const orm_helper_js_1 = require("./orm.helper.js");
 function serializeColumn(col, v) {
@@ -16,7 +16,6 @@ function serializeColumn(col, v) {
         return v.toJSON();
     return v;
 }
-exports.serializeColumn = serializeColumn;
 const padZero = (n) => (n < 9 ? '0' : '') + n;
 function serializeDataValue(dataType, v) {
     if (v == null)

package/esm/client/cursor.js

@@ -176,7 +176,7 @@ export class Cursor extends TypedEventEmitterClass(AsyncEventEmitter) {
             throw new Error('To move cursor back, it needs cache to be enabled');
         const _this = this;
         await this._taskQueue
-            .enqueue(async function () {
+            .enqueue(async () => {
             /* If moving backward */
             if (step < 0) {
                 /* Seek cache */

package/esm/client/extensions.js

@@ -1,9 +1,37 @@
-export let adapters = [];
-export function registerAdapter(adapter) {
-    if (!adapter.driver)
-        throw new TypeError('A DatabaseAdapter must contain "driver" property');
-    adapters.push(adapter);
-}
-export function unRegisterAdapter(...adapter) {
-    adapters = adapters.filter(x => !adapter.includes(x));
+export class AdapterRegistry {
+    static get size() {
+        return this.adapters.length;
+    }
+    static register(...adapters) {
+        for (const adapter of adapters) {
+            if (!adapter.driver)
+                throw new TypeError('A DatabaseAdapter must contain "driver" property');
+            this.adapters.push(adapter);
+        }
+    }
+    static forEach(callback, thisArg) {
+        return this.adapters.forEach(callback, thisArg);
+    }
+    static items() {
+        return this.adapters.values();
+    }
+    static unRegister(...extensions) {
+        this.adapters = extensions.filter(x => !extensions.includes(x));
+    }
+    static getAll(dialect) {
+        return this.adapters.filter(x => x.dialect === dialect);
+    }
+    static get(index) {
+        return this.adapters[index];
+    }
+    static findDialect(dialect) {
+        return this.adapters.find(x => x.dialect === dialect);
+    }
+    static findDriver(dialect) {
+        return this.adapters.find(x => x.driver === dialect);
+    }
+    static has(extension) {
+        return !!this.adapters.find(x => x === extension);
+    }
 }
+AdapterRegistry.adapters = [];

package/esm/client/helpers.js

@@ -16,6 +16,8 @@ export function applyNamingStrategy(value, namingStrategy) {
                 if (!value.match(/[a-z]/))
                     return pascalCase(value.toLowerCase());
                 return pascalCase(value);
+            default:
+                break;
         }
     }
     else if (typeof namingStrategy === 'function')

package/esm/client/sqb-client.js

@@ -4,7 +4,7 @@ import { coerceToBoolean, coerceToInt } from 'putil-varhelpers';
 import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
 import { EntityMetadata } from '../orm/model/entity-metadata.js';
 import { Repository } from '../orm/repository.class.js';
-import { adapters } from './extensions.js';
+import { AdapterRegistry } from './extensions.js';
 import { SqbConnection } from './sqb-connection.js';
 const debug = _debug('sqb:client');
 const inspect = Symbol.for('nodejs.util.inspect.custom');
@@ -16,12 +16,12 @@ export class SqbClient extends TypedEventEmitterClass(AsyncEventEmitter) {
             throw new TypeError('Configuration object required');
         let adapter;
         if (config.driver) {
-            adapter = adapters.find(x => x.driver === config.driver);
+            adapter = AdapterRegistry.findDriver(config.driver);
             if (!adapter)
                 throw new Error(`No database adapter registered for "${config.driver}" driver`);
         }
         else if (config.dialect) {
-            adapter = adapters.find(x => x.dialect === config.dialect);
+            adapter = AdapterRegistry.findDialect(config.dialect);
             if (!adapter)
                 throw new Error(`No database adapter registered for "${config.dialect}" dialect`);
         }

package/esm/client/sqb-connection.js

@@ -1,9 +1,9 @@
+import { classes } from '@sqb/builder';
 import assert from 'assert';
 import _debug from 'debug';
 import { TaskQueue } from 'power-tasks';
 import { coalesce, coerceToBoolean, coerceToInt, coerceToString } from 'putil-varhelpers';
 import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
-import { classes } from '@sqb/builder';
 import { EntityMetadata } from '../orm/model/entity-metadata.js';
 import { Repository } from '../orm/repository.class.js';
 import { Cursor } from './cursor.js';
@@ -187,8 +187,9 @@ export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
     async setSavepoint(savepoint) {
         if (!this._intlcon)
             throw new Error('Can not call setSavepoint() on a released connection');
-        if (typeof this._intlcon.setSavepoint !== 'function')
+        if (typeof this._intlcon.setSavepoint !== 'function') {
             throw new Error(this.client.driver + ' does not support setSavepoint method');
+        }
         if (!this.inTransaction)
             await this.startTransaction();
         await this._intlcon.setSavepoint(savepoint);
@@ -197,16 +198,18 @@ export class SqbConnection extends TypedEventEmitterClass(AsyncEventEmitter) {
     async releaseSavepoint(savepoint) {
         if (!this._intlcon)
             throw new Error('Can not call releaseSavepoint() on a released connection');
-        if (typeof this._intlcon.releaseSavepoint !== 'function')
+        if (typeof this._intlcon.releaseSavepoint !== 'function') {
             throw new Error(this.client.driver + ' does not support releaseSavepoint method');
+        }
         await this._intlcon.releaseSavepoint(savepoint);
         this.emit('release-savepoint');
     }
     async rollbackSavepoint(savepoint) {
         if (!this._intlcon)
             throw new Error('Can not call rollbackSavepoint() on a released connection');
-        if (typeof this._intlcon.rollbackSavepoint !== 'function')
+        if (typeof this._intlcon.rollbackSavepoint !== 'function') {
             throw new Error(this.client.driver + ' does not support rollbackSavepoint method');
+        }
         await this._intlcon.rollbackSavepoint(savepoint);
         this.emit('rollback-savepoint');
     }

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,6 +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/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';
-export * from './orm/backward.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';
@@ -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

@@ -244,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/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;