@sqb/connect 4.12.0 → 4.13.0

package/cjs/orm/decorators/events.decorator.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AfterDestroy = exports.AfterUpdate = exports.AfterInsert = exports.BeforeDestroy = exports.BeforeUpdate = exports.BeforeInsert = void 0;
+exports.BeforeInsert = BeforeInsert;
+exports.BeforeUpdate = BeforeUpdate;
+exports.BeforeDestroy = BeforeDestroy;
+exports.AfterInsert = AfterInsert;
+exports.AfterUpdate = AfterUpdate;
+exports.AfterDestroy = AfterDestroy;
 const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function BeforeInsert() {
     return (target, propertyKey) => {
@@ -11,7 +16,6 @@ function BeforeInsert() {
         entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-insert', fn);
     };
 }
-exports.BeforeInsert = BeforeInsert;
 function BeforeUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
@@ -21,7 +25,6 @@ function BeforeUpdate() {
         entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-update', fn);
     };
 }
-exports.BeforeUpdate = BeforeUpdate;
 function BeforeDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
@@ -31,7 +34,6 @@ function BeforeDestroy() {
         entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-destroy', fn);
     };
 }
-exports.BeforeDestroy = BeforeDestroy;
 function AfterInsert() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
@@ -41,7 +43,6 @@ function AfterInsert() {
         entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-insert', fn);
     };
 }
-exports.AfterInsert = AfterInsert;
 function AfterUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
@@ -51,7 +52,6 @@ function AfterUpdate() {
         entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-update', fn);
     };
 }
-exports.AfterUpdate = AfterUpdate;
 function AfterDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
@@ -61,4 +61,3 @@ function AfterDestroy() {
         entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-destroy', fn);
     };
 }
-exports.AfterDestroy = AfterDestroy;

package/cjs/orm/decorators/foreignkey.decorator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForeignKey = void 0;
+exports.ForeignKey = ForeignKey;
 const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function ForeignKey(type, targetKey) {
     return function (target, propertyKey) {
@@ -10,4 +10,3 @@ function ForeignKey(type, targetKey) {
         entity_metadata_js_1.EntityMetadata.addForeignKey(entity, propertyKey, type, targetKey);
     };
 }
-exports.ForeignKey = ForeignKey;

package/cjs/orm/decorators/index.decorator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Index = void 0;
+exports.Index = Index;
 const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function Index(arg0, arg1) {
     return function (target, propertyKey) {
@@ -18,4 +18,3 @@ function Index(arg0, arg1) {
         entity_metadata_js_1.EntityMetadata.addIndex(model, { ...arg0, columns: [propertyKey] });
     };
 }
-exports.Index = Index;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Link = void 0;
+exports.Link = Link;
 const entity_metadata_js_1 = require("../model/entity-metadata.js");
 const link_chain_js_1 = require("../model/link-chain.js");
 function Link(options) {
@@ -11,16 +11,19 @@ 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 (!entity_metadata_js_1.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 = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         // @ts-ignore
         // noinspection JSConstantReassignment
@@ -55,7 +58,6 @@ function Link(options) {
     };
     return fn;
 }
-exports.Link = Link;
 /**
  * Crates an Link Chain object
  */

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

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrimaryKey = void 0;
+exports.PrimaryKey = PrimaryKey;
 const entity_metadata_js_1 = require("../model/entity-metadata.js");
 const column_decorator_js_1 = require("./column.decorator.js");
 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 = entity_metadata_js_1.EntityMetadata.define(target);
             entity_metadata_js_1.EntityMetadata.setPrimaryKeys(meta, arg0, arg1);
             return;
@@ -21,4 +22,3 @@ function PrimaryKey(arg0, arg1) {
         entity_metadata_js_1.EntityMetadata.setPrimaryKeys(meta, propertyKey, arg0);
     };
 }
-exports.PrimaryKey = PrimaryKey;

package/cjs/orm/decorators/transform.decorator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serialize = exports.Parse = void 0;
+exports.Parse = Parse;
+exports.Serialize = Serialize;
 const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function Parse(fn) {
     return (target, propertyKey) => {
@@ -10,7 +11,6 @@ function Parse(fn) {
         entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey).parse = fn;
     };
 }
-exports.Parse = Parse;
 function Serialize(fn) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
@@ -19,4 +19,3 @@ function Serialize(fn) {
         entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey).serialize = fn;
     };
 }
-exports.Serialize = Serialize;

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/orm.const.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REPOSITORY_KEY = exports.ENTITY_METADATA_KEY = void 0;
+exports.DECORATOR_FACTORY = exports.REPOSITORY_KEY = exports.ENTITY_METADATA_KEY = void 0;
 exports.ENTITY_METADATA_KEY = Symbol.for('SQB_ENTITY_METADATA');
 exports.REPOSITORY_KEY = Symbol.for('SQB_REPOSITORY');
+exports.DECORATOR_FACTORY = Symbol.for('decorator.factory');

package/cjs/orm/repository.class.js

@@ -37,46 +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);
     }
-    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) => {
@@ -87,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;
@@ -132,11 +113,25 @@ class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(stric
             else
                 filter.push(options.filter);
         }
-        return !!(await count_command_js_1.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 find_command_js_1.FindCommand.execute({
             ...options,
             filter,
             entity: this._entity,
-        }));
+        });
+        return resp.length > 0;
     }
     async _count(options) {
         return count_command_js_1.CountCommand.execute({

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+class FieldsProjection {
+}
+exports.FieldsProjection = FieldsProjection;
+(function (FieldsProjection) {
+    class Item {
+    }
+    FieldsProjection.Item = Item;
+})(FieldsProjection || (exports.FieldsProjection = FieldsProjection = {}));
+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 = (0, fast_tokenizer_1.splitString)(input, {
+        delimiters: '.',
+        brackets: true,
+        keepBrackets: false,
+    });
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (f.includes(',')) {
+            const subFields = (0, fast_tokenizer_1.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();
+        }
+    }
+}

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');
     }