@rockster/core 0.0.1

package/core/services/locale-service.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var LocaleService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleService = void 0;
+const intl_1 = require("@formatjs/intl");
+const class_injector_1 = require("@rockster/class-injector");
+const common_1 = require("@rockster/common");
+const logger_1 = require("@rockster/logger");
+const path_1 = require("path");
+let LocaleService = LocaleService_1 = class LocaleService {
+    get default() {
+        return LocaleService_1._default;
+    }
+    get cache() {
+        return LocaleService_1._cache;
+    }
+    get memory() {
+        return LocaleService_1._memory;
+    }
+    init() {
+        if (!core.options.locale) {
+            return;
+        }
+        const logger = new logger_1.Logger('Locale');
+        const options = core.options.locale;
+        const directory = options.directory;
+        const localeFiles = tryReadDir(directory);
+        LocaleService_1._default = options.default;
+        for (const localeFile of localeFiles) {
+            const filePath = (0, path_1.join)(directory, localeFile);
+            const messages = require(filePath);
+            const [name] = localeFile.split('.');
+            const locale = common_1.Locale[name.replace('-', '')];
+            if (!locale) {
+                logger.throw(new Error(`${name} is not a valid locale`));
+            }
+            const config = {
+                locale,
+                messages,
+                onError: () => { }
+            };
+            this.memory[locale] = (0, intl_1.createIntl)(config, this.cache);
+        }
+    }
+    formatMessage({ locale, messageKey, replaces }) {
+        const intl = this.memory[locale || this.default] ||
+            this.memory[this.default];
+        return intl.formatMessage({ id: messageKey }, replaces);
+    }
+};
+exports.LocaleService = LocaleService;
+LocaleService._cache = (0, intl_1.createIntlCache)();
+LocaleService._memory = {};
+__decorate([
+    (0, class_injector_1.OnCreate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], LocaleService.prototype, "init", null);
+exports.LocaleService = LocaleService = LocaleService_1 = __decorate([
+    (0, class_injector_1.Injectable)()
+], LocaleService);

package/core/services/node-control.service.d.ts

@@ -0,0 +1,5 @@
+import { CacheClient } from "../../cache";
+export declare class NodeControlService {
+    protected cache: CacheClient;
+    registerNode(): Promise<void>;
+}

package/core/services/node-control.service.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeControlService = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const get_ip_address_1 = require("../../web-socket/functions/get-ip-address");
+const crypto_1 = require("crypto");
+const uuid_1 = require("uuid");
+const cache_1 = require("../../cache");
+let NodeControlService = class NodeControlService {
+    async registerNode() {
+        const address = (0, get_ip_address_1.getIpAddress)();
+        const port = core.options.port;
+        const url = `${address}:${port}`;
+        const privateKey = (0, crypto_1.createHmac)('sha256', (0, uuid_1.v4)()).digest('hex');
+        const key = `ROCKET:NODE:${core.options.name}:${url}`;
+        core.privateKey = privateKey;
+        core.nodeKey = key;
+        await this.cache.set(key, JSON.stringify({
+            address: address,
+            port: port,
+            url: url,
+            privateKey: privateKey,
+        }));
+        await this.cache.expire(key, 600);
+        setTimeout(() => {
+            this.registerNode();
+        }, 600000);
+    }
+};
+exports.NodeControlService = NodeControlService;
+__decorate([
+    (0, cache_1.InjectCache)(),
+    __metadata("design:type", Object)
+], NodeControlService.prototype, "cache", void 0);
+exports.NodeControlService = NodeControlService = __decorate([
+    (0, class_injector_1.Injectable)()
+], NodeControlService);

package/core/services/object-loader.d.ts

@@ -0,0 +1,10 @@
+import { Instantiable } from "@rockster/common";
+import { ObjectNote } from "@rockster/class-memory";
+import { Object } from "../interfaces";
+import { ObjectType } from "../../common";
+export declare abstract class ObjectLoader<T extends Object> {
+    protected abstract objects: ObjectNote<T>[];
+    abstract build(targets: Instantiable[]): Promise<void> | void;
+    protected load(current: ObjectNote<Object>[], type: ObjectType, targets: Instantiable[]): ObjectNote<Object>[];
+    protected each(callback: (object: ObjectNote<T>) => Promise<void>): Promise<void>;
+}

package/core/services/object-loader.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectLoader = void 0;
+class ObjectLoader {
+    load(current, type, targets) {
+        for (const target of targets) {
+            const object = core
+                .storage
+                .findObject(target);
+            if (object?.type === type) {
+                const compare = (source, target) => (source.objectClass === target.objectClass);
+                current.pushIfNotExists(object, compare);
+            }
+        }
+        return current;
+    }
+    async each(callback) {
+        for (const object of this.objects) {
+            if (object.initialized) {
+                continue;
+            }
+            await callback(object);
+            object.initialized = true;
+        }
+    }
+}
+exports.ObjectLoader = ObjectLoader;

package/core/services/request-executor.d.ts

@@ -0,0 +1,9 @@
+import { PendingAction, IRequestContext } from "../interfaces";
+export declare class RequestExecutor {
+    executeByDataSource(context: IRequestContext): Promise<import("@rockster/common").Dictionary<any>>;
+    executeByTransaction(context: IRequestContext): Promise<import("@rockster/common").Dictionary<any>>;
+    protected executeBefore(context: IRequestContext): Promise<void>;
+    protected executeActions(context: IRequestContext): Promise<void>;
+    protected executeSuccessCallbacks(context: IRequestContext): Promise<void>;
+    protected executeErrorCallbacks(error: Error, pending: PendingAction, context: IRequestContext): Promise<void>;
+}

package/core/services/request-executor.js

@@ -0,0 +1,108 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestExecutor = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const transaction_context_1 = require("../../database/contexts/transaction-context");
+let RequestExecutor = class RequestExecutor {
+    async executeByDataSource(context) {
+        for (const pending of context.pendings) {
+            try {
+                await pending.action.onBefore(pending, context);
+            }
+            catch (error) {
+                error.requestRef = pending.requestRef;
+                throw error;
+            }
+        }
+        for (const pending of context.pendings) {
+            try {
+                await pending.action.execute(pending, context);
+            }
+            catch (error) {
+                error.requestRef = pending.requestRef;
+                throw error;
+            }
+        }
+        return context.response;
+    }
+    async executeByTransaction(context) {
+        await this.executeBefore(context);
+        await this.executeActions(context);
+        await this.executeSuccessCallbacks(context);
+        return context.response;
+    }
+    async executeBefore(context) {
+        for (const pending of context.pendings) {
+            try {
+                await pending.action.onBefore(pending, context);
+            }
+            catch (error) {
+                error.requestRef = pending.requestRef;
+                await this
+                    .executeErrorCallbacks(error, pending, context);
+                throw error;
+            }
+        }
+    }
+    async executeActions(context) {
+        let actionError;
+        const dataSource = core.database.dataSource;
+        const queryRunner = dataSource.createQueryRunner();
+        const entityManager = queryRunner.manager;
+        context.entityManager = entityManager;
+        await transaction_context_1.transactionContextStore.run({ entityManager }, async () => {
+            try {
+                await queryRunner.connect();
+                await queryRunner.startTransaction();
+                for (const pending of context.pendings) {
+                    try {
+                        await pending.action.execute(pending, context);
+                    }
+                    catch (error) {
+                        error.requestRef = pending.requestRef;
+                        actionError = error;
+                        await this
+                            .executeErrorCallbacks(error, pending, context);
+                        throw error;
+                    }
+                }
+                await queryRunner.commitTransaction();
+            }
+            catch (error) {
+                await queryRunner.rollbackTransaction();
+            }
+            finally {
+                await queryRunner.release();
+            }
+        });
+        if (actionError) {
+            throw actionError;
+        }
+    }
+    async executeSuccessCallbacks(context) {
+        for (const callback of context.callbacks.success) {
+            await callback.handle();
+        }
+    }
+    async executeErrorCallbacks(error, pending, context) {
+        const callbacks = context
+            .callbacks
+            .error
+            .filter((callback) => {
+            return callback.name === pending.path;
+        });
+        for (const callback of callbacks) {
+            await callback.handle(error);
+        }
+    }
+};
+exports.RequestExecutor = RequestExecutor;
+exports.RequestExecutor = RequestExecutor = __decorate([
+    (0, class_injector_1.Injectable)()
+], RequestExecutor);

package/core/services/request-router.d.ts

@@ -0,0 +1,15 @@
+import { HttpController } from "../../http";
+import { RequestExecutor } from "./request-executor";
+import { ContextBuilder } from "./context-builder";
+import { Logger } from "@rockster/logger";
+export declare class RequestRouter {
+    protected contextBuilder: ContextBuilder;
+    protected requestExecutor: RequestExecutor;
+    protected requestPath: string;
+    protected docsPath: string;
+    protected logger: Logger;
+    constructor(contextBuilder: ContextBuilder, requestExecutor: RequestExecutor);
+    start(http: HttpController): void;
+    protected postRequest(http: HttpController): void;
+    protected getDocs(http: HttpController): void;
+}

package/core/services/request-router.js

@@ -0,0 +1,127 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestRouter = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const security_1 = require("../../security");
+const request_executor_1 = require("./request-executor");
+const context_builder_1 = require("./context-builder");
+const logger_1 = require("@rockster/logger");
+const database_1 = require("../../database");
+const use_auth_1 = require("../../security/functions/use-auth");
+const class_pipe_1 = require("@rockster/class-pipe");
+const common_1 = require("@rockster/common");
+let RequestRouter = class RequestRouter {
+    constructor(contextBuilder, requestExecutor) {
+        this.contextBuilder = contextBuilder;
+        this.requestExecutor = requestExecutor;
+        this.requestPath = '/request';
+        this.docsPath = '/docs';
+        this.logger = new logger_1.Logger('Docs');
+    }
+    start(http) {
+        this.postRequest(http);
+        this.getDocs(http);
+    }
+    postRequest(http) {
+        const method = common_1.HttpMethod.post;
+        const transaction = (0, database_1.useTransaction)();
+        const execute = transaction
+            ? this
+                .requestExecutor
+                .executeByTransaction
+                .bind(this.requestExecutor)
+            : this
+                .requestExecutor
+                .executeByDataSource
+                .bind(this.requestExecutor);
+        http.addRoute(method, this.requestPath, async (req, res) => {
+            try {
+                const requestContext = this
+                    .contextBuilder
+                    .build({
+                    body: req.body,
+                    headers: req.headers,
+                    httpRequest: req
+                });
+                if (requestContext.isAuthenticated && (0, security_1.isAuthEnabled)() && !req.isWs) {
+                    requestContext.session = await (0, use_auth_1.useAuth)().httpInterceptor(req);
+                }
+                if (req.isWs) {
+                    requestContext.session = req.session;
+                }
+                const result = await execute(requestContext);
+                res.status(common_1.HttpStatus.ok).json(result);
+            }
+            catch (error) {
+                const code = error.httpCode || common_1.HttpStatus.internalServerError;
+                const body = code === common_1.HttpStatus.internalServerError ? null : error;
+                res.status(code).json(body);
+                core.options?.onRequestError?.apply(this, [error]);
+            }
+        });
+    }
+    getDocs(http) {
+        const method = common_1.HttpMethod.get;
+        const actions = core
+            .actions
+            .filter((action) => {
+            return action.docs;
+        })
+            .map((action) => {
+            return action.docs;
+        });
+        const models = core.models.map((model) => {
+            const objectDocs = (0, class_pipe_1.getDocs)(model);
+            objectDocs.properties.forEach((propertyDocs) => {
+                const propertyNote = core
+                    .storage
+                    .findProperty(model, propertyDocs.name);
+                propertyDocs.onlyModify = propertyNote?.onlyModify;
+                propertyDocs.readOnly = propertyNote?.readOnly;
+            });
+            return objectDocs;
+        });
+        if (core.options.docs) {
+            if (core.options.docs.public) {
+                http.addRoute(method, this.docsPath, (req, res) => {
+                    res.status(common_1.HttpStatus.ok).json({
+                        actions,
+                        models
+                    });
+                });
+            }
+            else {
+                http.addRoute(method, this.docsPath, async (req, res) => {
+                    try {
+                        await (0, use_auth_1.useAuth)().httpInterceptor(req);
+                        res.status(common_1.HttpStatus.ok).json({
+                            actions,
+                            models
+                        });
+                    }
+                    catch (error) {
+                        const code = error.httpCode ||
+                            common_1.HttpStatus.internalServerError;
+                        res.status(code).json(error);
+                    }
+                });
+            }
+            this.logger.log('Enabled');
+        }
+    }
+};
+exports.RequestRouter = RequestRouter;
+exports.RequestRouter = RequestRouter = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [context_builder_1.ContextBuilder,
+        request_executor_1.RequestExecutor])
+], RequestRouter);

package/database/contexts/index.d.ts

@@ -0,0 +1 @@
+export * from './transaction-context';

package/database/contexts/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./transaction-context"), exports);

package/database/contexts/transaction-context.d.ts

@@ -0,0 +1,6 @@
+import { AsyncLocalStorage } from "async_hooks";
+import { EntityManager } from "typeorm";
+export type TransactionContextStore = {
+    entityManager: EntityManager;
+};
+export declare const transactionContextStore: AsyncLocalStorage<TransactionContextStore>;

package/database/contexts/transaction-context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionContextStore = void 0;
+const async_hooks_1 = require("async_hooks");
+exports.transactionContextStore = new async_hooks_1.AsyncLocalStorage();

package/database/database.controller.d.ts

@@ -0,0 +1,20 @@
+import { Instantiable } from "@rockster/common";
+import { DataSource } from "typeorm";
+import { ObjectNote } from "@rockster/class-memory";
+import { ObjectLoader } from "../core";
+import { IEntityObject } from "./interfaces";
+import { PathsBuilder } from "./services/paths-builder";
+import { ProtectBuilder } from "./services/protect-builder";
+export declare class DatabaseController extends ObjectLoader<IEntityObject> {
+    protected pathsBuilder: PathsBuilder;
+    protected protectBuilder: ProtectBuilder;
+    static _objects: ObjectNote<IEntityObject>[];
+    static _dataSource: DataSource;
+    protected get objects(): ObjectNote<IEntityObject>[];
+    get dataSource(): DataSource;
+    protected set dataSource(value: DataSource);
+    constructor(pathsBuilder: PathsBuilder, protectBuilder: ProtectBuilder);
+    addMigrations(migrations: (string | Function)[]): Promise<void>;
+    build(targets: Instantiable[]): Promise<void>;
+    initialize(): Promise<void>;
+}

package/database/database.controller.js

@@ -0,0 +1,92 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var DatabaseController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseController = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const typeorm_1 = require("typeorm");
+const logger_1 = require("@rockster/logger");
+const core_1 = require("../core");
+const common_1 = require("../common");
+const paths_builder_1 = require("./services/paths-builder");
+const protect_builder_1 = require("./services/protect-builder");
+const environment_1 = require("./environment");
+const typeorm_naming_strategies_1 = require("typeorm-naming-strategies");
+let DatabaseController = DatabaseController_1 = class DatabaseController extends core_1.ObjectLoader {
+    get objects() {
+        return DatabaseController_1._objects;
+    }
+    get dataSource() {
+        return DatabaseController_1._dataSource;
+    }
+    set dataSource(value) {
+        DatabaseController_1._dataSource = value;
+    }
+    constructor(pathsBuilder, protectBuilder) {
+        super();
+        this.pathsBuilder = pathsBuilder;
+        this.protectBuilder = protectBuilder;
+    }
+    async addMigrations(migrations) {
+        if (!core.options?.database.migrations) {
+            core.options.database = {
+                ...core.options.database,
+                migrations: []
+            };
+        }
+        migrations.forEach((migration) => {
+            const migrations = core
+                .options
+                .database
+                .migrations;
+            migrations.push(migration);
+        });
+    }
+    async build(targets) {
+        super.load(this.objects, common_1.ObjectType.entity, targets);
+        await this.each(async (object) => {
+            await this.pathsBuilder.build(object);
+            await this.protectBuilder.build(object);
+        });
+    }
+    async initialize() {
+        if (this.dataSource) {
+            return;
+        }
+        environment_1.environment
+            .oneToManyRegistrations
+            .forEach((value) => {
+            value.handle();
+        });
+        const logger = new logger_1.Logger('Database');
+        this.dataSource =
+            new typeorm_1.DataSource({
+                type: 'postgres',
+                ...core.options.database,
+                namingStrategy: new typeorm_naming_strategies_1.SnakeNamingStrategy(),
+                entities: this
+                    .objects
+                    .map((entity) => {
+                    return entity.objectClass;
+                })
+            });
+        await this.dataSource.initialize();
+        core.database = this;
+        logger.log('Successfully connected');
+    }
+};
+exports.DatabaseController = DatabaseController;
+DatabaseController._objects = [];
+exports.DatabaseController = DatabaseController = DatabaseController_1 = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [paths_builder_1.PathsBuilder,
+        protect_builder_1.ProtectBuilder])
+], DatabaseController);

package/database/decorators/column.decorator.d.ts

@@ -0,0 +1,72 @@
+import { ColumnOptions } from "typeorm";
+import { ColumnCommonOptions } from "typeorm/decorator/options/ColumnCommonOptions";
+import { ColumnEmbeddedOptions } from "typeorm/decorator/options/ColumnEmbeddedOptions";
+import { ColumnEnumOptions } from "typeorm/decorator/options/ColumnEnumOptions";
+import { ColumnHstoreOptions } from "typeorm/decorator/options/ColumnHstoreOptions";
+import { ColumnNumericOptions } from "typeorm/decorator/options/ColumnNumericOptions";
+import { ColumnWithLengthOptions } from "typeorm/decorator/options/ColumnWithLengthOptions";
+import { SpatialColumnOptions } from "typeorm/decorator/options/SpatialColumnOptions";
+import { SimpleColumnType, SpatialColumnType, WithLengthColumnType, WithPrecisionColumnType } from "typeorm/driver/types/ColumnTypes";
+/**
+ * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this
+ * decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(options: ColumnOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: SimpleColumnType, options?: ColumnCommonOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: SpatialColumnType, options?: ColumnCommonOptions & SpatialColumnOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: WithLengthColumnType, options?: ColumnCommonOptions & ColumnWithLengthOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: WithPrecisionColumnType, options?: ColumnCommonOptions & ColumnNumericOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "enum", options?: ColumnCommonOptions & ColumnEnumOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "simple-enum", options?: ColumnCommonOptions & ColumnEnumOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "set", options?: ColumnCommonOptions & ColumnEnumOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "hstore", options?: ColumnCommonOptions & ColumnHstoreOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ *
+ * Property in entity can be marked as Embedded, and on persist all columns from the embedded are mapped to the
+ * single table of the entity where Embedded is used. And on hydration all columns which supposed to be in the
+ * embedded will be mapped to it from the single table.
+ */
+export declare function Column(type: (type?: any) => Function, options?: ColumnEmbeddedOptions): any;

package/database/decorators/column.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Column = Column;
+const column_decorator_1 = require("../functions/column-decorator");
+function Column(type, options) {
+    return (target, propertyKey) => {
+        (0, column_decorator_1.columnDecorator)(target, propertyKey, type, options);
+    };
+}

package/database/decorators/entity.decorator.d.ts

@@ -0,0 +1,2 @@
+import { IEntityOptions } from "../interfaces";
+export declare const Entity: (options?: IEntityOptions) => (target: any) => void;