@sqb/connect 4.0.9 → 4.0.13

package/dist/orm/util/entity-mapping.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitEntity = exports.PickEntity = exports.UnionEntity = exports.omitEntityInto = exports.pickEntityInto = exports.mixinEntities = void 0;
+const entity_model_1 = require("../model/entity-model");
+const association_1 = require("../model/association");
+const index_meta_1 = require("../model/index-meta");
+function mixinEntities(derived, classARef, classBRef, classCRef, classDRef, classERef, classFRef) {
+    const trg = entity_model_1.EntityModel.attachTo(derived);
+    for (const classRef of [classARef, classBRef, classCRef, classDRef, classERef, classFRef]) {
+        if (!classRef)
+            continue;
+        const src = entity_model_1.EntityModel.get(classRef);
+        if (!src)
+            return derived;
+        trg.tableName = src.tableName;
+        if (!trg.primaryIndex && src.primaryIndex) {
+            trg.primaryIndex = new index_meta_1.IndexMeta(trg, src.primaryIndex.columns, src.primaryIndex);
+        }
+        if (src.foreignKeys) {
+            trg.foreignKeys = trg.foreignKeys || [];
+            for (const fk of src.foreignKeys) {
+                const newFk = new association_1.Association(fk.name, { ...fk, source: derived });
+                trg.foreignKeys.push(newFk);
+            }
+        }
+        if (src.indexes) {
+            trg.indexes = trg.indexes || [];
+            for (const idx of src.indexes) {
+                const newIdx = new index_meta_1.IndexMeta(trg, idx.columns, idx);
+                trg.indexes.push(newIdx);
+            }
+        }
+        if (src.eventListeners) {
+            trg.eventListeners = trg.eventListeners || [];
+            trg.eventListeners.push(...src.eventListeners);
+        }
+        src.elements.forEach((p, n) => {
+            const o = Object.assign({}, p);
+            o.entity = trg;
+            Object.setPrototypeOf(o, Object.getPrototypeOf(p));
+            trg.elements.set(n, o);
+        });
+    }
+    return derived;
+}
+exports.mixinEntities = mixinEntities;
+function pickEntityInto(derived, classRef, keys) {
+    const trg = entity_model_1.EntityModel.attachTo(derived);
+    const src = entity_model_1.EntityModel.get(classRef);
+    if (!src)
+        return derived;
+    trg.tableName = src.tableName;
+    trg.schema = src.schema;
+    trg.comment = src.comment;
+    trg.primaryIndex = src.primaryIndex;
+    const pickKeys = keys.map(x => x.toLowerCase());
+    for (const fk of src.foreignKeys) {
+        if (fk.sourceKey && pickKeys.includes(fk.sourceKey.toLowerCase())) {
+            const newFk = new association_1.Association(fk.name, { ...fk, source: derived });
+            trg.foreignKeys.push(newFk);
+        }
+    }
+    for (const idx of src.indexes) {
+        if (!idx.columns.find(x => !pickKeys.includes(x.toLowerCase()))) {
+            const newIdx = new index_meta_1.IndexMeta(trg, idx.columns, idx);
+            trg.indexes.push(newIdx);
+        }
+    }
+    trg.eventListeners.push(...src.eventListeners);
+    src.elements.forEach((p, n) => {
+        if (pickKeys.includes(n))
+            trg.elements.set(n, p);
+    });
+    return derived;
+}
+exports.pickEntityInto = pickEntityInto;
+function omitEntityInto(derived, classRef, keys) {
+    const trg = entity_model_1.EntityModel.attachTo(derived);
+    const src = entity_model_1.EntityModel.get(classRef);
+    if (!src)
+        return derived;
+    trg.tableName = src.tableName;
+    trg.schema = src.schema;
+    trg.comment = src.comment;
+    trg.primaryIndex = src.primaryIndex;
+    const omitKeys = keys.map(x => x.toLowerCase());
+    for (const fk of src.foreignKeys) {
+        if (!(fk.sourceKey && omitKeys.includes(fk.sourceKey.toLowerCase()))) {
+            const newFk = new association_1.Association(fk.name, { ...fk, source: derived });
+            trg.foreignKeys.push(newFk);
+        }
+    }
+    for (const idx of src.indexes) {
+        if (!idx.columns.find(x => omitKeys.includes(x.toLowerCase()))) {
+            const newIdx = new index_meta_1.IndexMeta(trg, idx.columns, idx);
+            trg.indexes.push(newIdx);
+        }
+    }
+    trg.eventListeners.push(...src.eventListeners);
+    src.elements.forEach((p, n) => {
+        if (!omitKeys.includes(n.toLowerCase()))
+            trg.elements.set(n.toLowerCase(), p);
+    });
+    trg.elements.forEach((p, n) => {
+        if (omitKeys.includes(n.toLowerCase()))
+            trg.elements.delete(n.toLowerCase());
+    });
+    return derived;
+}
+exports.omitEntityInto = omitEntityInto;
+function UnionEntity(classARef, classBRef) {
+    class UnionEntityClass {
+        constructor(...args) {
+            inheritPropertyInitializers(this, classARef, args);
+            inheritPropertyInitializers(this, classBRef, args);
+        }
+    }
+    return mixinEntities(UnionEntityClass, classARef, classBRef);
+}
+exports.UnionEntity = UnionEntity;
+function PickEntity(classRef, keys) {
+    class PickEntityClass {
+        constructor(...args) {
+            inheritPropertyInitializers(this, classRef, args);
+        }
+    }
+    return pickEntityInto(PickEntityClass, classRef, keys);
+}
+exports.PickEntity = PickEntity;
+function OmitEntity(classRef, keys) {
+    class OmitEntityClass {
+        constructor(...args) {
+            inheritPropertyInitializers(this, classRef, args);
+        }
+    }
+    return omitEntityInto(OmitEntityClass, classRef, keys);
+}
+exports.OmitEntity = OmitEntity;
+function inheritPropertyInitializers(target, sourceClass, constructorArgs, isPropertyInherited) {
+    try {
+        const tempInstance = new sourceClass(...constructorArgs);
+        const keys = Object.getOwnPropertyNames(tempInstance);
+        for (const key of keys) {
+            const srcDesc = Object.getOwnPropertyDescriptor(tempInstance, key);
+            const trgDesc = Object.getOwnPropertyDescriptor(target, key);
+            if (!srcDesc || trgDesc || (isPropertyInherited && !isPropertyInherited(key)))
+                continue;
+            Object.defineProperty(target, key, srcDesc);
+        }
+    }
+    catch {
+        //
+    }
+}

package/dist/orm/util/extract-keyvalues.d.ts

@@ -0,0 +1,2 @@
+import { EntityModel } from '../model/entity-model';
+export declare function extractKeyValues<T>(entityDef: EntityModel, valueOrInstance: any | Record<string, any> | T, keepOther?: boolean): Record<string, any>;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractKeyValues = void 0;
+const orm_helper_1 = require("./orm.helper");
+function extractKeyValues(entityDef, valueOrInstance, keepOther) {
+    const primaryIndex = entityDef.primaryIndex;
+    if (!primaryIndex)
+        throw new Error(`No primary fields defined for "${entityDef.name}" entity`);
+    const validateCol = (k) => {
+        const col = entityDef.getElement(k);
+        if (!col)
+            throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);
+        if (!(0, orm_helper_1.isColumnElement)(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')
+            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 = {};
+        for (const k of primaryIndex.columns) {
+            const i = valueKeysUpper.indexOf(k.toUpperCase());
+            if (i < 0)
+                throw new Error(`Value of key field "${entityDef.name}.${k}" required to perform this operation`);
+            validateCol(k);
+            out[k] = valueOrInstance[valueKeys[i]];
+        }
+        if (keepOther) {
+            for (let i = 0; i < valueKeys.length; i++) {
+                if (primaryIndex.columns.find(x => x.toUpperCase() === valueKeysUpper[i]))
+                    continue;
+                out[valueKeys[i]] = valueOrInstance[valueKeys[i]];
+            }
+        }
+        return out;
+    }
+    const primaryColumnName = primaryIndex.columns[0];
+    validateCol(primaryColumnName);
+    if (typeof valueOrInstance === 'object') {
+        const valueKeys = Object.keys(valueOrInstance);
+        const valueKeysUpper = valueKeys.map(x => x.toUpperCase());
+        const k = valueKeysUpper.indexOf(primaryColumnName.toUpperCase());
+        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++) {
+                if (primaryIndex.columns.find(x => x.toUpperCase() === valueKeysUpper[i]))
+                    continue;
+                out[valueKeys[i]] = valueOrInstance[valueKeys[i]];
+            }
+        }
+        return out;
+    }
+    return { [primaryColumnName]: valueOrInstance };
+}
+exports.extractKeyValues = extractKeyValues;

package/dist/orm/util/orm.helper.d.ts

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+import { Type } from 'ts-gems';
+import type { TypeThunk } from '../orm.type';
+import type { EntityModel } from '../model/entity-model';
+import type { EntityColumnElement } from '../model/entity-column-element';
+import type { EntityObjectElement } from '../model/entity-object-element';
+import type { EntityAssociationElement } from '../model/entity-association-element';
+export declare function isClass(fn: any): fn is Type;
+export declare function isEntityClass(fn: any): fn is Type;
+export declare function isColumnElement(f: any): f is EntityColumnElement;
+export declare const isObjectElement: (f: any) => f is EntityObjectElement;
+export declare const isAssociationElement: (f: any) => f is EntityAssociationElement;
+export declare function resolveEntity(ctorThunk: TypeThunk): Promise<Type | undefined>;
+export declare function resolveEntityMeta(ctorThunk: TypeThunk): Promise<EntityModel | undefined>;

package/dist/orm/util/orm.helper.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEntityMeta = exports.resolveEntity = exports.isAssociationElement = exports.isObjectElement = exports.isColumnElement = exports.isEntityClass = exports.isClass = void 0;
+require("reflect-metadata");
+const orm_const_1 = require("../orm.const");
+function isClass(fn) {
+    return typeof fn === 'function' && /^\s*class/.test(fn.toString());
+}
+exports.isClass = isClass;
+function isEntityClass(fn) {
+    return !!(isClass(fn) && fn[orm_const_1.ENTITY_DEFINITION_KEY]);
+}
+exports.isEntityClass = isEntityClass;
+function isColumnElement(f) {
+    return !!(f && f.entity && f.kind === 'column');
+}
+exports.isColumnElement = isColumnElement;
+const isObjectElement = (f) => {
+    return !!(f && f.entity && f.kind === 'object');
+};
+exports.isObjectElement = isObjectElement;
+const isAssociationElement = (f) => {
+    return !!(f && f.entity && f.kind === 'association');
+};
+exports.isAssociationElement = isAssociationElement;
+async function resolveEntity(ctorThunk) {
+    if (typeof ctorThunk !== 'function')
+        return;
+    if (!isClass(ctorThunk))
+        ctorThunk = await ctorThunk();
+    if (isEntityClass(ctorThunk))
+        return ctorThunk;
+}
+exports.resolveEntity = resolveEntity;
+async function resolveEntityMeta(ctorThunk) {
+    const ctor = await resolveEntity(ctorThunk);
+    return ctor && ctor[orm_const_1.ENTITY_DEFINITION_KEY];
+}
+exports.resolveEntityMeta = resolveEntityMeta;

package/dist/orm/util/serialize-element.d.ts

@@ -0,0 +1,2 @@
+import { AbstractEntityelement } from '../model/abstract-entityelement';
+export declare function serializeColumn(col: AbstractEntityelement, v: any): any;

package/dist/orm/util/serialize-element.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeColumn = void 0;
+const builder_1 = require("@sqb/builder");
+const orm_helper_1 = require("./orm.helper");
+function serializeColumn(col, v) {
+    if ((0, orm_helper_1.isColumnElement)(col)) {
+        if (col.isArray) {
+            if (Array.isArray(v))
+                return v.map(x => serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, x));
+            return [serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v)];
+        }
+        return serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v);
+    }
+    if (typeof v === 'object' && typeof v.toJSON === 'function')
+        return v.toJSON();
+    return v;
+}
+exports.serializeColumn = serializeColumn;
+const padZero = (n) => (n < 9 ? '0' : '') + n;
+function serializeDataValue(dataType, v) {
+    if (v == null)
+        return;
+    if (v instanceof Date &&
+        (dataType === builder_1.DataType.DATE || dataType === builder_1.DataType.TIMESTAMP)) {
+        return v.getFullYear() + '-' +
+            padZero(v.getMonth() + 1) + '-' +
+            padZero(v.getDate()) + (dataType === builder_1.DataType.TIMESTAMP ?
+            'T' + padZero(v.getHours()) + ':' +
+                padZero(v.getMinutes()) + ':' +
+                padZero(v.getSeconds()) : '');
+    }
+    if (v instanceof Buffer)
+        return v.toString('base64');
+    if (typeof v === 'number' && (dataType === builder_1.DataType.SMALLINT ||
+        dataType === builder_1.DataType.INTEGER))
+        return Math.trunc(v);
+    if (typeof v === 'bigint')
+        return v.toString();
+    if (v && typeof v === 'object' && typeof v.toJSON === 'function')
+        return v.toJSON();
+    return v;
+}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { DeepPartial, DeepPickWritable } from 'ts-gems';
+export declare type InstanceValues<T> = DeepPartial<DeepPickWritable<T>>;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.0.9",
-  "author": "Panates Ltd.",
+  "version": "4.0.13",
+  "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
   ],
@@ -39,7 +39,7 @@
     "putil-varhelpers": "^1.6.1",
     "reflect-metadata": "^0.1.13",
     "strict-typed-events": "^2.1.0",
-    "ts-gems": "^1.1.2"
+    "ts-gems": "^1.5.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.6",