@sqb/connect 4.2.1 → 4.5.0

package/{dist → cjs}/orm/decorators/events.decorator.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AfterDestroy = exports.AfterUpdate = exports.AfterInsert = exports.BeforeDestroy = exports.BeforeUpdate = exports.BeforeInsert = void 0;
-const entity_metadata_1 = require("../model/entity-metadata");
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function BeforeInsert() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = entity_metadata_1.EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        entity_metadata_1.EntityMetadata.addEventListener(model, 'before-insert', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-insert', fn);
     };
 }
 exports.BeforeInsert = BeforeInsert;
@@ -16,9 +16,9 @@ function BeforeUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = entity_metadata_1.EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        entity_metadata_1.EntityMetadata.addEventListener(model, 'before-update', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-update', fn);
     };
 }
 exports.BeforeUpdate = BeforeUpdate;
@@ -26,9 +26,9 @@ function BeforeDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = entity_metadata_1.EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        entity_metadata_1.EntityMetadata.addEventListener(model, 'before-destroy', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'before-destroy', fn);
     };
 }
 exports.BeforeDestroy = BeforeDestroy;
@@ -36,9 +36,9 @@ function AfterInsert() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = entity_metadata_1.EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        entity_metadata_1.EntityMetadata.addEventListener(model, 'after-insert', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-insert', fn);
     };
 }
 exports.AfterInsert = AfterInsert;
@@ -46,9 +46,9 @@ function AfterUpdate() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = entity_metadata_1.EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        entity_metadata_1.EntityMetadata.addEventListener(model, 'after-update', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-update', fn);
     };
 }
 exports.AfterUpdate = AfterUpdate;
@@ -56,9 +56,9 @@ function AfterDestroy() {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const model = entity_metadata_1.EntityMetadata.define(target.constructor);
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
         const fn = target.constructor.prototype[propertyKey];
-        entity_metadata_1.EntityMetadata.addEventListener(model, 'after-destroy', fn);
+        entity_metadata_js_1.EntityMetadata.addEventListener(model, 'after-destroy', fn);
     };
 }
 exports.AfterDestroy = AfterDestroy;

package/{dist → cjs}/orm/decorators/foreignkey.decorator.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForeignKey = void 0;
-const entity_metadata_1 = require("../model/entity-metadata");
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function ForeignKey(type, targetKey) {
     return function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
             throw new Error('Symbol properties are not accepted');
-        const entity = entity_metadata_1.EntityMetadata.define(target.constructor);
-        entity_metadata_1.EntityMetadata.addForeignKey(entity, propertyKey, type, targetKey);
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.addForeignKey(entity, propertyKey, type, targetKey);
     };
 }
 exports.ForeignKey = ForeignKey;

package/{dist → cjs}/orm/decorators/index.decorator.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Index = void 0;
-const entity_metadata_1 = require("../model/entity-metadata");
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function Index(arg0, arg1) {
     return function (target, propertyKey) {
         if (typeof target === 'function') {
             if (!(typeof arg0 === 'string' || Array.isArray(arg0)))
                 throw new Error(`You must specify index column(s)`);
-            const model = entity_metadata_1.EntityMetadata.define(target);
-            return entity_metadata_1.EntityMetadata.addIndex(model, { ...arg1, columns: arg0 });
+            const model = entity_metadata_js_1.EntityMetadata.define(target);
+            return entity_metadata_js_1.EntityMetadata.addIndex(model, { ...arg1, columns: arg0 });
         }
         if (!target.constructor)
             throw new Error('Property decorators can be used for class properties only');
         if (typeof propertyKey !== 'string')
             throw new Error('Index() decorator can be used for string property keys only');
-        const model = entity_metadata_1.EntityMetadata.define(target.constructor);
-        entity_metadata_1.EntityMetadata.addIndex(model, { ...arg0, columns: [propertyKey] });
+        const model = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.addIndex(model, { ...arg0, columns: [propertyKey] });
     };
 }
 exports.Index = Index;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Link = void 0;
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
+const link_chain_js_1 = require("../model/link-chain.js");
+function Link(options) {
+    let root;
+    let chain;
+    const fn = (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError('Symbol properties are not allowed');
+        const reflectType = Reflect.getMetadata("design:type", target, propertyKey);
+        if (!root) {
+            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())
+            throw new TypeError(`Link returns single instance however property type is an array`);
+        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
+        root.first.source = entity.ctor;
+        entity_metadata_js_1.EntityMetadata.defineAssociationField(entity, propertyKey, root.first, options);
+    };
+    fn.toOne = (type, args) => {
+        if (chain) {
+            chain = chain.linkToOne(type, args?.targetKey, args?.sourceKey);
+            if (args?.where)
+                chain.where(args.where);
+            return fn;
+        }
+        root = linkToOne(type, args?.targetKey, args?.sourceKey);
+        chain = root;
+        if (args?.where)
+            chain.where(args.where);
+        return fn;
+    };
+    fn.toMany = (type, args) => {
+        if (chain) {
+            chain = chain.linkToMany(type, args?.targetKey, args?.sourceKey);
+            if (args?.where)
+                chain.where(args.where);
+            return fn;
+        }
+        root = linkToMany(type, args?.targetKey, args?.sourceKey);
+        chain = root;
+        if (args?.where)
+            chain.where(args.where);
+        return fn;
+    };
+    return fn;
+}
+exports.Link = Link;
+/**
+ * Crates an Link Chain object
+ */
+function linkToOne(type, targetKey, sourceKey) {
+    return new link_chain_js_1.LinkChain(type, targetKey, sourceKey);
+}
+/**
+ * Crates an Link Chain object
+ */
+function linkToMany(type, targetKey, sourceKey) {
+    return new link_chain_js_1.LinkChain(type, targetKey, sourceKey, true);
+}

package/{dist → cjs}/orm/decorators/primarykey.decorator.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrimaryKey = void 0;
-const entity_metadata_1 = require("../model/entity-metadata");
-const column_decorator_1 = require("./column.decorator");
+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)))
                 throw new Error(`You must specify primary index column(s)`);
-            const meta = entity_metadata_1.EntityMetadata.define(target);
-            entity_metadata_1.EntityMetadata.setPrimaryKeys(meta, arg0, arg1);
+            const meta = entity_metadata_js_1.EntityMetadata.define(target);
+            entity_metadata_js_1.EntityMetadata.setPrimaryKeys(meta, arg0, arg1);
             return;
         }
         if (!target.constructor)
             throw new Error('Property decorators can be used for class properties only');
         if (typeof propertyKey !== 'string')
             throw new Error('Index() decorator can be used for string property keys only');
-        const meta = entity_metadata_1.EntityMetadata.define(target.constructor);
-        (0, column_decorator_1.Column)({ notNull: true })(target, propertyKey);
-        entity_metadata_1.EntityMetadata.setPrimaryKeys(meta, propertyKey, arg0);
+        const meta = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        (0, column_decorator_js_1.Column)({ notNull: true })(target, propertyKey);
+        entity_metadata_js_1.EntityMetadata.setPrimaryKeys(meta, propertyKey, arg0);
     };
 }
 exports.PrimaryKey = PrimaryKey;

package/{dist → cjs}/orm/decorators/transform.decorator.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Serialize = exports.Parse = void 0;
-const entity_metadata_1 = require("../model/entity-metadata");
+const entity_metadata_js_1 = require("../model/entity-metadata.js");
 function Parse(fn) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_metadata_1.EntityMetadata.define(target.constructor);
-        entity_metadata_1.EntityMetadata.defineColumnElement(entity, propertyKey)
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey)
             .parse = fn;
     };
 }
@@ -16,8 +16,8 @@ function Serialize(fn) {
     return (target, propertyKey) => {
         if (typeof propertyKey !== 'string')
             throw new Error('You can define a Column for only string properties');
-        const entity = entity_metadata_1.EntityMetadata.define(target.constructor);
-        entity_metadata_1.EntityMetadata.defineColumnElement(entity, propertyKey)
+        const entity = entity_metadata_js_1.EntityMetadata.define(target.constructor);
+        entity_metadata_js_1.EntityMetadata.defineColumnField(entity, propertyKey)
             .serialize = fn;
     };
 }

package/cjs/orm/model/association-field-metadata.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociationFieldMetadata = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+var AssociationFieldMetadata;
+(function (AssociationFieldMetadata) {
+    function create(entity, name, association, options = {}) {
+        const result = {
+            kind: 'association',
+            entity,
+            name,
+            association
+        };
+        if (options)
+            AssociationFieldMetadata.assign(result, options);
+        return result;
+    }
+    AssociationFieldMetadata.create = create;
+    function assign(target, options) {
+        Object.assign(target, lodash_1.default.omit(options, ['entity', 'name', 'kind', 'association']));
+    }
+    AssociationFieldMetadata.assign = assign;
+})(AssociationFieldMetadata = exports.AssociationFieldMetadata || (exports.AssociationFieldMetadata = {}));

package/{dist → cjs}/orm/model/association-node.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssociationNode = void 0;
-const association_1 = require("./association");
-class AssociationNode extends association_1.Association {
+const association_js_1 = require("./association.js");
+class AssociationNode extends association_js_1.Association {
+    prior;
+    next;
+    conditions;
     getFirst() {
         let l = this;
         while (l.prior)

package/{dist → cjs}/orm/model/association.js

@@ -2,25 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Association = void 0;
 const putil_varhelpers_1 = require("putil-varhelpers");
-const orm_helper_1 = require("../util/orm.helper");
-const entity_metadata_1 = require("./entity-metadata");
+const orm_helper_js_1 = require("../util/orm.helper.js");
+const entity_metadata_js_1 = require("./entity-metadata.js");
 class Association {
+    _resolved;
+    _source; // cached value
+    _target; // cached value
+    _sourceKey; // cached value
+    _targetKey; // cached value
+    _sourceProperty;
+    _targetProperty;
+    name;
+    source;
+    target;
+    sourceKey;
+    targetKey;
+    many;
     constructor(name, args) {
         this.name = name;
         this.source = args.source;
         this.target = args.target;
         this.sourceKey = args.sourceKey;
         this.targetKey = args.targetKey;
-        this.kind = args.kind;
+        this.many = !!args.many;
     }
     async resolveSource() {
-        this._source = await (0, orm_helper_1.resolveEntityMeta)(this.source);
+        this._source = await (0, orm_helper_js_1.resolveEntityMeta)(this.source);
         if (!this._source)
             throw new Error(`Can't resolve source entity of association "${this.name}"`);
         return this._source;
     }
     async resolveTarget() {
-        this._target = await (0, orm_helper_1.resolveEntityMeta)(this.target);
+        this._target = await (0, orm_helper_js_1.resolveEntityMeta)(this.target);
         if (!this._target)
             throw new Error(`Can't resolve target entity of association "${this.name}"`);
         return this._target;
@@ -45,11 +58,8 @@ class Association {
         // @ts-ignore
         return this._targetProperty;
     }
-    get sourceBelongsToTarget() {
-        return this.kind === 'from' || this.kind === 'from-many';
-    }
     returnsMany() {
-        return this.kind === 'to-many' || this.kind === 'from-many';
+        return this.many;
     }
     async _resolveKeys() {
         if (this._resolved)
@@ -60,7 +70,7 @@ class Association {
         let targetKey = this.targetKey;
         if (!(sourceKey && targetKey)) {
             // Try to determine key fields from foreign key from source to target
-            let foreign = await entity_metadata_1.EntityMetadata.getForeignKeyFor(source, target);
+            let foreign = await entity_metadata_js_1.EntityMetadata.getForeignKeyFor(source, target);
             if (foreign && foreign !== this) {
                 await foreign._resolveKeys();
                 this._sourceKey = foreign._sourceKey;
@@ -71,7 +81,7 @@ class Association {
             }
             else {
                 // Try to determine key fields from foreign key from target to source
-                foreign = await entity_metadata_1.EntityMetadata.getForeignKeyFor(target, source);
+                foreign = await entity_metadata_js_1.EntityMetadata.getForeignKeyFor(target, source);
                 if (foreign && foreign !== this) {
                     await foreign._resolveKeys();
                     this._sourceKey = foreign._targetKey;
@@ -81,46 +91,28 @@ class Association {
                     return;
                 }
             }
-            let master;
-            let detail;
-            let masterKey;
-            let detailKey;
-            if (this.sourceBelongsToTarget) {
-                master = target;
-                detail = source;
-                masterKey = targetKey || '';
-                detailKey = sourceKey || '';
-            }
-            else {
-                master = source;
-                detail = target;
-                detailKey = targetKey || '';
-                masterKey = sourceKey || '';
-            }
+            const master = source;
+            const detail = target;
+            let masterKey = sourceKey || '';
+            let detailKey = targetKey || '';
             if (!detailKey) {
-                const primaryIndexColumns = entity_metadata_1.EntityMetadata.getPrimaryIndexColumns(detail);
+                const primaryIndexColumns = entity_metadata_js_1.EntityMetadata.getPrimaryIndexColumns(detail);
                 detailKey = primaryIndexColumns && primaryIndexColumns.length === 1 ?
                     primaryIndexColumns[0].name : 'id';
             }
             if (!masterKey) {
                 // snake-case
                 masterKey = detail.name[0].toLowerCase() + detail.name.substring(1) + '_' + detailKey;
-                if (!entity_metadata_1.EntityMetadata.getColumnElement(master, masterKey))
+                if (!entity_metadata_js_1.EntityMetadata.getColumnField(master, masterKey))
                     masterKey = (0, putil_varhelpers_1.camelCase)(masterKey);
             }
-            if (this.sourceBelongsToTarget) {
-                targetKey = masterKey;
-                sourceKey = detailKey;
-            }
-            else {
-                targetKey = detailKey;
-                sourceKey = masterKey;
-            }
+            targetKey = detailKey;
+            sourceKey = masterKey;
         }
-        this._targetProperty = entity_metadata_1.EntityMetadata.getColumnElement(target, targetKey);
+        this._targetProperty = entity_metadata_js_1.EntityMetadata.getColumnField(target, targetKey);
         if (!this._targetProperty)
             throw new Error(`Can't determine target key of ${this.name}`);
-        this._sourceProperty = entity_metadata_1.EntityMetadata.getColumnElement(source, sourceKey);
+        this._sourceProperty = entity_metadata_js_1.EntityMetadata.getColumnField(source, sourceKey);
         if (!this._sourceProperty)
             throw new Error(`Can't determine source key of ${this.name}`);
         this._targetKey = targetKey;

package/{dist/orm/model/column-element-metadata.js → cjs/orm/model/column-field-metadata.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnElementMetadata = void 0;
+exports.ColumnFieldMetadata = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
-var ColumnElementMetadata;
-(function (ColumnElementMetadata) {
+var ColumnFieldMetadata;
+(function (ColumnFieldMetadata) {
     function create(entity, name, options = {}) {
         const result = {
             kind: 'column',
@@ -13,14 +13,14 @@ var ColumnElementMetadata;
             fieldName: name
         };
         if (options)
-            ColumnElementMetadata.assign(result, options);
+            ColumnFieldMetadata.assign(result, options);
         return result;
     }
-    ColumnElementMetadata.create = create;
+    ColumnFieldMetadata.create = create;
     function assign(target, options) {
         Object.assign(target, lodash_1.default.omit(options, ['entity', 'name', 'kind']));
     }
-    ColumnElementMetadata.assign = assign;
+    ColumnFieldMetadata.assign = assign;
     function checkEnumValue(col, v) {
         if (v === undefined || !col.enum || (v == null && !col.notNull))
             return;
@@ -28,5 +28,5 @@ var ColumnElementMetadata;
         if (!enumKeys.includes(v))
             throw new Error(`${col.entity.name}.${col.name} value must be one of (${enumKeys})`);
     }
-    ColumnElementMetadata.checkEnumValue = checkEnumValue;
-})(ColumnElementMetadata = exports.ColumnElementMetadata || (exports.ColumnElementMetadata = {}));
+    ColumnFieldMetadata.checkEnumValue = checkEnumValue;
+})(ColumnFieldMetadata = exports.ColumnFieldMetadata || (exports.ColumnFieldMetadata = {}));

package/{dist/orm/model/embedded-element-metadata.js → cjs/orm/model/embedded-field-metadata.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmbeddedElementMetadata = void 0;
-const orm_helper_1 = require("../util/orm.helper");
-var EmbeddedElementMetadata;
-(function (EmbeddedElementMetadata) {
+exports.EmbeddedFieldMetadata = void 0;
+const orm_helper_js_1 = require("../util/orm.helper.js");
+var EmbeddedFieldMetadata;
+(function (EmbeddedFieldMetadata) {
     function create(entity, name, type, options) {
         const result = {
             kind: 'object',
@@ -17,12 +17,12 @@ var EmbeddedElementMetadata;
             result.fieldNameSuffix = options.fieldNameSuffix;
         return result;
     }
-    EmbeddedElementMetadata.create = create;
+    EmbeddedFieldMetadata.create = create;
     async function resolveType(meta) {
-        const typ = await (0, orm_helper_1.resolveEntityMeta)(meta.type);
+        const typ = await (0, orm_helper_js_1.resolveEntityMeta)(meta.type);
         if (typ)
             return typ;
         throw new Error(`Can't resolve type of ${meta.entity.name}.${meta.name}`);
     }
-    EmbeddedElementMetadata.resolveType = resolveType;
-})(EmbeddedElementMetadata = exports.EmbeddedElementMetadata || (exports.EmbeddedElementMetadata = {}));
+    EmbeddedFieldMetadata.resolveType = resolveType;
+})(EmbeddedFieldMetadata = exports.EmbeddedFieldMetadata || (exports.EmbeddedFieldMetadata = {}));