@sqb/connect 4.2.1 → 4.5.0

package/esm/orm/repository.class.js

@@ -0,0 +1,238 @@
+import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
+import { SqbConnection } from '../client/sqb-connection.js';
+import { CountCommand } from './commands/count.command.js';
+import { CreateCommand } from './commands/create.command.js';
+import { DestroyCommand } from './commands/destroy.command.js';
+import { FindCommand } from './commands/find.command.js';
+import { UpdateCommand } from './commands/update.command.js';
+import { extractKeyValues } from './util/extract-keyvalues.js';
+export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
+    _executor;
+    _entity;
+    _schema;
+    constructor(entityDef, executor, schema) {
+        super();
+        this._executor = executor;
+        this._entity = entityDef;
+        this._schema = schema;
+    }
+    get entity() {
+        return this._entity;
+    }
+    get type() {
+        return this._entity.ctor;
+    }
+    create(values, options) {
+        return this._execute(async (connection) => {
+            return this._create(values, { ...options, connection });
+        }, options);
+    }
+    createOnly(values, options) {
+        return this._execute(async (connection) => {
+            return this._createOnly(values, { ...options, connection });
+        }, options);
+    }
+    exists(keyValue, options) {
+        return this._execute(async (connection) => {
+            return this._exists(keyValue, { ...options, connection });
+        }, options);
+    }
+    count(options) {
+        return this._execute(async (connection) => {
+            return this._count({ ...options, connection });
+        }, options);
+    }
+    findAll(options) {
+        return this._execute(async (connection) => {
+            return this._findAll({ ...options, connection });
+        }, options);
+    }
+    findOne(options) {
+        return this._execute(async (connection) => {
+            return this._findOne({ ...options, connection });
+        }, options);
+    }
+    findByPk(keyValue, options) {
+        return this._execute(async (connection) => {
+            return this._findByPk(keyValue, { ...options, connection });
+        }, options);
+    }
+    destroy(keyValue, options) {
+        return this._execute(async (connection) => {
+            return this._destroy(keyValue, { ...options, connection });
+        }, options);
+    }
+    destroyAll(options) {
+        return this._execute(async (connection) => {
+            return this._destroyAll({ ...options, connection });
+        }, options);
+    }
+    update(keyValue, values, options) {
+        return this._execute(async (connection) => {
+            const opts = { ...options, connection };
+            const keyValues = await this._update(keyValue, values, opts);
+            if (keyValues)
+                return this._findByPk(keyValues, opts);
+        }, options);
+    }
+    updateOnly(keyValue, values, options) {
+        return this._execute(async (connection) => {
+            return !!(await this._update(keyValue, values, { ...options, connection }));
+        }, options);
+    }
+    updateAll(values, options) {
+        return this._execute(async (connection) => {
+            return this._updateAll(values, { ...options, connection });
+        });
+    }
+    async _execute(fn, opts) {
+        let connection = opts?.connection;
+        if (!connection && this._executor instanceof SqbConnection)
+            connection = this._executor;
+        if (connection) {
+            if (this._schema)
+                await connection.setSchema(this._schema);
+            return fn(connection);
+        }
+        return this._executor.acquire(async (conn) => {
+            if (this._schema)
+                await conn.setSchema(this._schema);
+            await this.emitAsyncSerial('acquire', conn);
+            return fn(conn);
+        });
+    }
+    async _create(values, options) {
+        await this._emit('before-create', values, options);
+        const keyValues = await CreateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values,
+            returning: true
+        });
+        const result = keyValues && (await this.findByPk(keyValues, options));
+        if (!result)
+            throw new Error('Unable to insert new row');
+        await this._emit('after-create', result, options);
+        return result;
+    }
+    async _createOnly(values, options) {
+        await this._emit('before-create', values, options);
+        await CreateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values,
+            returning: false
+        });
+    }
+    async _exists(keyValue, options) {
+        const filter = [extractKeyValues(this._entity, keyValue, true)];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        return !!(await CountCommand.execute({
+            ...options,
+            filter,
+            entity: this._entity
+        }));
+    }
+    async _count(options) {
+        return CountCommand.execute({
+            ...options,
+            entity: this._entity
+        });
+    }
+    async _findAll(options) {
+        return await FindCommand.execute({
+            ...options,
+            entity: this._entity,
+        });
+    }
+    async _findOne(options) {
+        const rows = await FindCommand.execute({
+            ...options,
+            entity: this._entity,
+            limit: 1
+        });
+        return rows && rows[0];
+    }
+    async _findByPk(keyValue, options) {
+        const filter = [extractKeyValues(this._entity, keyValue, true)];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        return await this._findOne({ ...options, filter, offset: 0 });
+    }
+    async _destroy(keyValue, options) {
+        await this._emit('before-destroy', keyValue, options);
+        const filter = [extractKeyValues(this._entity, keyValue, true)];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        const result = !!(await DestroyCommand.execute({
+            ...options,
+            filter,
+            entity: this._entity,
+        }));
+        await this._emit('after-destroy', result, keyValue, options);
+        return result;
+    }
+    async _destroyAll(options) {
+        await this._emit('before-destroy-all', options);
+        const rowsAffected = DestroyCommand.execute({
+            ...options,
+            entity: this._entity,
+            filter: options?.filter,
+            params: options?.params
+        });
+        await this._emit('after-destroy-all', rowsAffected, options);
+        return rowsAffected;
+    }
+    async _update(keyValue, values, options) {
+        await this._emit('before-update', keyValue, values, options);
+        const keyValues = extractKeyValues(this._entity, keyValue, true);
+        const filter = [keyValues];
+        if (options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        const updateValues = { ...values };
+        Object.keys(keyValues).forEach(k => delete updateValues[k]);
+        const rowsAffected = await UpdateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values: updateValues,
+            filter
+        });
+        await this._emit('after-update', rowsAffected, keyValues, options);
+        return rowsAffected ? keyValues : undefined;
+    }
+    async _updateAll(values, options) {
+        await this._emit('before-update-all', values, options);
+        const rowsAffected = await UpdateCommand.execute({
+            ...options,
+            entity: this._entity,
+            values
+        });
+        await this._emit('after-update-all', rowsAffected, values, options);
+        return rowsAffected;
+    }
+    async _emit(event, ...args) {
+        const events = this._entity.eventListeners && this._entity.eventListeners[event];
+        if (events) {
+            for (const fn of events) {
+                await fn(this, ...args);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+export 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))
+            continue;
+        Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
+            Object.create(null));
+    }
+}

package/{dist → esm}/orm/util/extract-keyvalues.d.ts

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

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

@@ -0,0 +1,57 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { isColumnField } from './orm.helper.js';
+export function extractKeyValues(entityDef, valueOrInstance, keepOther) {
+    const primaryIndex = EntityMetadata.getPrimaryIndex(entityDef);
+    if (!primaryIndex)
+        throw new Error(`No primary fields defined for "${entityDef.name}" entity`);
+    const validateCol = (k) => {
+        const col = EntityMetadata.getField(entityDef, k);
+        if (!col)
+            throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);
+        if (!isColumnField(col))
+            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 };
+}

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

@@ -0,0 +1,13 @@
+import { Type } from 'ts-gems';
+import { AssociationFieldMetadata } from '../model/association-field-metadata.js';
+import type { ColumnFieldMetadata } from '../model/column-field-metadata.js';
+import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import type { EntityMetadata } from '../model/entity-metadata.js';
+import type { TypeThunk } from '../orm.type.js';
+export declare function isClass(fn: any): fn is Type;
+export declare function isEntityClass(fn: any): fn is Type;
+export declare function isColumnField(f: any): f is ColumnFieldMetadata;
+export declare const isEmbeddedField: (f: any) => f is EmbeddedFieldMetadata;
+export declare const isAssociationField: (f: any) => f is AssociationFieldMetadata;
+export declare function resolveEntity(ctorThunk: TypeThunk): Promise<Type | undefined>;
+export declare function resolveEntityMeta(ctorThunk: TypeThunk): Promise<EntityMetadata | undefined>;

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

@@ -0,0 +1,28 @@
+import { ENTITY_METADATA_KEY } from '../orm.const.js';
+export function isClass(fn) {
+    return typeof fn === 'function' && /^\s*class/.test(fn.toString());
+}
+export function isEntityClass(fn) {
+    return isClass(fn) && Reflect.hasMetadata(ENTITY_METADATA_KEY, fn);
+}
+export function isColumnField(f) {
+    return !!(f && f.name && f.kind === 'column');
+}
+export const isEmbeddedField = (f) => {
+    return !!(f && f.name && f.kind === 'object');
+};
+export const isAssociationField = (f) => {
+    return !!(f && f.name && f.kind === 'association');
+};
+export async function resolveEntity(ctorThunk) {
+    if (typeof ctorThunk !== 'function')
+        return;
+    if (!isClass(ctorThunk))
+        ctorThunk = await ctorThunk();
+    if (isEntityClass(ctorThunk))
+        return ctorThunk;
+}
+export async function resolveEntityMeta(ctorThunk) {
+    const ctor = await resolveEntity(ctorThunk);
+    return ctor && Reflect.getMetadata(ENTITY_METADATA_KEY, ctor);
+}

package/esm/orm/util/serialize-field.d.ts

@@ -0,0 +1,2 @@
+import { FieldMetadata } from '../model/field-metadata.js';
+export declare function serializeColumn(col: FieldMetadata, v: any): any;

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

@@ -0,0 +1,39 @@
+import { DataType } from '@sqb/builder';
+import { isColumnField } from './orm.helper.js';
+export function serializeColumn(col, v) {
+    if (isColumnField(col)) {
+        if (col.isArray) {
+            if (Array.isArray(v))
+                return v.map(x => serializeDataValue(col.dataType || DataType.VARCHAR, x));
+            return [serializeDataValue(col.dataType || DataType.VARCHAR, v)];
+        }
+        return serializeDataValue(col.dataType || DataType.VARCHAR, v);
+    }
+    if (typeof v === 'object' && typeof v.toJSON === 'function')
+        return v.toJSON();
+    return v;
+}
+const padZero = (n) => (n < 9 ? '0' : '') + n;
+function serializeDataValue(dataType, v) {
+    if (v == null)
+        return;
+    if (v instanceof Date &&
+        (dataType === DataType.DATE || dataType === DataType.TIMESTAMP)) {
+        return v.getFullYear() + '-' +
+            padZero(v.getMonth() + 1) + '-' +
+            padZero(v.getDate()) + (dataType === 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 === DataType.SMALLINT ||
+        dataType === 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/esm/types.d.ts

@@ -0,0 +1,7 @@
+import { Builtin, DeepPickWritable } from 'ts-gems';
+export declare type EntityData<T> = DeepNullableIfPartial<DeepPickWritable<T>>;
+export declare type DeepNullableIfPartial<T> = _DeepNullableIfPartial<T>;
+declare type _DeepNullableIfPartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullableIfPartial<U>> : T extends (infer U)[] ? DeepNullableIfPartial<U>[] : {
+    [P in keyof T]?: DeepNullableIfPartial<Exclude<T[P], undefined> | null>;
+};
+export {};

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.2.1",
+  "version": "4.5.0",
   "author": "Panates",
   "contributors": [
-    "Eray Hanoglu <e.hanoglu@panates.com>"
+    "Eray Hanoglu <e.hanoglu@panates.com>",
+    "Ilker Gurelli <i.gurelli@panates.com>"
   ],
   "license": "Apache-2.0",
   "repository": {
@@ -12,23 +13,21 @@
     "url": "https://github.com/sqbjs/sqb.git",
     "directory": "packages/connect"
   },
-  "keywords": [
-    "javascript",
-    "typescript",
-    "sqb",
-    "rdbms",
-    "sql",
-    "client",
-    "dialect",
-    "multi-dialect",
-    "database",
-    "oracle",
-    "postgres",
-    "pg",
-    "mssql",
-    "sqlite",
-    "mysql"
-  ],
+  "scripts": {
+    "compile": "tsc",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig-build-cjs.json",
+    "build:esm": "tsc -b tsconfig-build-esm.json",
+    "postbuild": "cp README.md package.json ../../LICENSE ../../build/connect && cp ../../package.cjs.json ../../build/connect/cjs/package.json",
+    "lint": "eslint .",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
+    "clean": "npm run clean:src | npm run clean:dist | npm run clean:cover",
+    "clean:src": "ts-cleanup -s src --all",
+    "clean:dist": "rimraf ../../build/connectt",
+    "clean:cover": "rimraf ../../coverage/connect"
+  },
   "dependencies": {
     "debug": "^4.3.4",
     "lightning-pool": "^3.1.4",
@@ -44,33 +43,47 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
-    "@types/lodash": "^4.14.182"
+    "@types/lodash": "^4.14.184"
   },
   "peerDependencies": {
-    "@sqb/builder": "^4.2.0"
+    "@sqb/builder": "^4.5.0"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "engines": {
-    "node": ">= 16.0"
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
   },
-  "directories": {
-    "lib": "dist",
-    "test": "test"
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
   },
   "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
     "LICENSE",
-    "README.md",
-    "dist/"
+    "README.md"
   ],
-  "scripts": {
-    "build": "tsc -b tsconfig-build.json",
-    "prebuild": "npm run lint && npm run clean:dist",
-    "postbuild": "copyfiles package.json README.md LICENSE ../../build/connect",
-    "clean": "ts-cleanup -s src --all & ts-cleanup -s test",
-    "clean:dist": "rimraf ../../build/connect",
-    "compile": "tsc",
-    "lint": "eslint src/** --no-error-on-unmatched-pattern",
-    "test": "TS_NODE_PROJECT='./test/tsconfig.json' mocha -r ts-node/register -r tsconfig-paths/register --reporter spec test/**/*.spec.ts"
-  }
-}
+  "keywords": [
+    "sqb",
+    "rdbms",
+    "sql",
+    "client",
+    "dialect",
+    "multi-dialect",
+    "database",
+    "oracle",
+    "postgres",
+    "pg",
+    "mssql",
+    "sqlite",
+    "mysql"
+  ]
+}

package/dist/index.d.ts

@@ -1,33 +0,0 @@
-import 'reflect-metadata';
-export { Type, Maybe, DeepPartial, DeepPickWritable, DeepBuildable } from 'ts-gems';
-export * from './types';
-export * from './client/types';
-export * from './client/Adapter';
-export * from './client/SqbClient';
-export * from './client/SqbConnection';
-export * from './client/Cursor';
-export { registerAdapter, unRegisterAdapter } from './client/extensions';
-export * from './orm/orm.type';
-export * from './orm/orm.const';
-export * from './orm/base-entity';
-export * from './orm/repository.class';
-export * from './orm/model/entity-metadata';
-export * from './orm/model/element-metadata';
-export * from './orm/model/column-element-metadata';
-export * from './orm/model/embedded-element-metadata';
-export * from './orm/model/association-element-metadata';
-export * from './orm/model/association';
-export * from './orm/model/association-node';
-export * from './orm/model/index-metadata';
-export * from './orm/model/link-chain';
-export * from './orm/decorators/column.decorator';
-export * from './orm/decorators/embedded.decorator';
-export * from './orm/decorators/entity.decorator';
-export * from './orm/decorators/events.decorator';
-export * from './orm/decorators/foreignkey.decorator';
-export * from './orm/decorators/index.decorator';
-export * from './orm/decorators/link.decorator';
-export * from './orm/decorators/primarykey.decorator';
-export * from './orm/decorators/transform.decorator';
-export { isColumnElement, isEmbeddedElement, isAssociationElement, isEntityClass } from './orm/util/orm.helper';
-export * from './orm/backward';

package/dist/index.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEntityClass = exports.isAssociationElement = exports.isEmbeddedElement = exports.isColumnElement = exports.unRegisterAdapter = exports.registerAdapter = void 0;
-const tslib_1 = require("tslib");
-require("reflect-metadata");
-tslib_1.__exportStar(require("./types"), exports);
-tslib_1.__exportStar(require("./client/types"), exports);
-tslib_1.__exportStar(require("./client/Adapter"), exports);
-tslib_1.__exportStar(require("./client/SqbClient"), exports);
-tslib_1.__exportStar(require("./client/SqbConnection"), exports);
-tslib_1.__exportStar(require("./client/Cursor"), exports);
-var extensions_1 = require("./client/extensions");
-Object.defineProperty(exports, "registerAdapter", { enumerable: true, get: function () { return extensions_1.registerAdapter; } });
-Object.defineProperty(exports, "unRegisterAdapter", { enumerable: true, get: function () { return extensions_1.unRegisterAdapter; } });
-tslib_1.__exportStar(require("./orm/orm.type"), exports);
-tslib_1.__exportStar(require("./orm/orm.const"), exports);
-tslib_1.__exportStar(require("./orm/base-entity"), exports);
-tslib_1.__exportStar(require("./orm/repository.class"), exports);
-tslib_1.__exportStar(require("./orm/model/entity-metadata"), exports);
-tslib_1.__exportStar(require("./orm/model/element-metadata"), exports);
-tslib_1.__exportStar(require("./orm/model/column-element-metadata"), exports);
-tslib_1.__exportStar(require("./orm/model/embedded-element-metadata"), exports);
-tslib_1.__exportStar(require("./orm/model/association-element-metadata"), exports);
-tslib_1.__exportStar(require("./orm/model/association"), exports);
-tslib_1.__exportStar(require("./orm/model/association-node"), exports);
-tslib_1.__exportStar(require("./orm/model/index-metadata"), exports);
-tslib_1.__exportStar(require("./orm/model/link-chain"), exports);
-tslib_1.__exportStar(require("./orm/decorators/column.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/embedded.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/entity.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/events.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/foreignkey.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/index.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/link.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/primarykey.decorator"), exports);
-tslib_1.__exportStar(require("./orm/decorators/transform.decorator"), exports);
-var orm_helper_1 = require("./orm/util/orm.helper");
-Object.defineProperty(exports, "isColumnElement", { enumerable: true, get: function () { return orm_helper_1.isColumnElement; } });
-Object.defineProperty(exports, "isEmbeddedElement", { enumerable: true, get: function () { return orm_helper_1.isEmbeddedElement; } });
-Object.defineProperty(exports, "isAssociationElement", { enumerable: true, get: function () { return orm_helper_1.isAssociationElement; } });
-Object.defineProperty(exports, "isEntityClass", { enumerable: true, get: function () { return orm_helper_1.isEntityClass; } });
-tslib_1.__exportStar(require("./orm/backward"), exports);

package/dist/orm/decorators/column.decorator.d.ts

@@ -1,4 +0,0 @@
-import { DataType } from '@sqb/builder';
-import { ColumnElementOptions } from '../model/column-element-metadata';
-export declare function Column(type?: DataType): PropertyDecorator;
-export declare function Column(options?: ColumnElementOptions): PropertyDecorator;

package/dist/orm/decorators/embedded.decorator.d.ts

@@ -1,3 +0,0 @@
-import { EmbeddedElementOptions } from '../model/embedded-element-metadata';
-import { TypeThunk } from '../orm.type';
-export declare function Embedded(type?: TypeThunk, options?: EmbeddedElementOptions): PropertyDecorator;