@rockster/core 0.0.1

package/database/decorators/entity.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const entity_decorator_1 = require("../functions/entity-decorator");
+const Entity = (options) => {
+    return (target) => {
+        (0, entity_decorator_1.entityDecorator)(target, options);
+    };
+};
+exports.Entity = Entity;

package/database/decorators/id-generated.decorator.d.ts

@@ -0,0 +1,30 @@
+import { PrimaryGeneratedColumnIdentityOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnIdentityOptions";
+import { PrimaryGeneratedColumnNumericOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnNumericOptions";
+import { PrimaryGeneratedColumnUUIDOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnUUIDOptions";
+import { NanoIdColumnOpitons } from "../interfaces/nano-id-column-options";
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function IdGenerated(): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function IdGenerated(options: PrimaryGeneratedColumnNumericOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function IdGenerated(strategy: "increment", options?: PrimaryGeneratedColumnNumericOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function IdGenerated(strategy: "uuid", options?: PrimaryGeneratedColumnUUIDOptions): any;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function IdGenerated(strategy: "rowid", options?: PrimaryGeneratedColumnUUIDOptions): any;
+export declare function IdGenerated(strategy: "identity", options?: PrimaryGeneratedColumnIdentityOptions): any;
+export declare function IdGenerated(strategy: "uuid", options?: PrimaryGeneratedColumnUUIDOptions): any;
+export declare function IdGenerated(strategy: "uuid.v4", options?: PrimaryGeneratedColumnUUIDOptions): any;
+export declare function IdGenerated(strategy: 'uuid.v7', options?: PrimaryGeneratedColumnUUIDOptions): any;
+export declare function IdGenerated(strategy: "cuid.v2", options?: PrimaryGeneratedColumnUUIDOptions): any;
+export declare function IdGenerated(strategy: 'nanoid', options?: NanoIdColumnOpitons): any;

package/database/decorators/id-generated.decorator.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdGenerated = IdGenerated;
+const register_generated_id_1 = require("../functions/register-generated-id");
+const get_primitive_type_1 = require("../functions/get-primitive-type");
+const get_column_type_1 = require("../functions/get-column-type");
+const register_id_1 = require("../functions/register-id");
+const cuid2_1 = require("@paralleldrive/cuid2");
+const nanoid_1 = require("nanoid");
+const uuid_1 = require("uuid");
+const nano_id_alphabet_type_1 = require("../interfaces/enum/nano-id-alphabet-type");
+const get_name_by_strategy_1 = require("../functions/get-name-by-strategy");
+function IdGenerated(strategy, options) {
+    return (target, propertyKey) => {
+        const property = core
+            .storage
+            .createProperty(target, propertyKey);
+        property.strategy = strategy;
+        property.isIdProperty = true;
+        if (strategy === 'nanoid') {
+            const defaultOptions = {
+                size: 12,
+                customAlphabet: nano_id_alphabet_type_1.NanoIdAlphabetType
+                    .lowerCaseLettersAndDigits,
+                ...options
+            };
+            const createNanoId = (0, nanoid_1.customAlphabet)(defaultOptions.customAlphabet, defaultOptions.size);
+            property.getNewId = createNanoId;
+            (0, register_id_1.registerId)({
+                target,
+                propertyKey,
+                type: 'varchar'
+            });
+        }
+        else if (strategy === 'uuid.v7') {
+            property.getNewId = uuid_1.v7;
+            (0, register_id_1.registerId)({
+                target,
+                propertyKey,
+                type: 'varchar'
+            });
+        }
+        else if (strategy === 'uuid.v4') {
+            property.getNewId = uuid_1.v4;
+            (0, register_id_1.registerId)({
+                target,
+                propertyKey,
+                type: 'varchar'
+            });
+        }
+        else if (strategy === 'cuid.v2') {
+            property.getNewId = cuid2_1.createId;
+            (0, register_id_1.registerId)({
+                target,
+                propertyKey,
+                type: 'varchar'
+            });
+        }
+        else {
+            (0, register_generated_id_1.registerGeneratedId)({
+                propertyKey,
+                target,
+                options,
+                strategy
+            });
+        }
+        property.primitiveType =
+            (0, get_primitive_type_1.getPrimitiveType)(property);
+        property.columnType =
+            (0, get_column_type_1.getColumnType)(property);
+        property.columnName = (0, get_name_by_strategy_1.getNameByStrategy)({
+            overrideName: options?.name ?? strategy?.name,
+            name: property.propertyKey
+        });
+    };
+}

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

@@ -0,0 +1,13 @@
+import { ColumnType, PrimaryColumnOptions } from "typeorm";
+/**
+ * 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.
+ * Primary columns also creates a PRIMARY KEY for this column in a db.
+ */
+export declare function Id(options?: PrimaryColumnOptions): 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.
+ * Primary columns also creates a PRIMARY KEY for this column in a db.
+ */
+export declare function Id(type?: ColumnType, options?: PrimaryColumnOptions): any;

package/database/decorators/id.decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Id = Id;
+const register_id_1 = require("../functions/register-id");
+const get_column_type_1 = require("../functions/get-column-type");
+const get_primitive_type_1 = require("../functions/get-primitive-type");
+const get_name_by_strategy_1 = require("../functions/get-name-by-strategy");
+function Id(type, options) {
+    return (target, propertyKey) => {
+        (0, register_id_1.registerId)({
+            type,
+            propertyKey,
+            target,
+            options
+        });
+        const property = core
+            .storage
+            .createProperty(target, propertyKey);
+        property.isIdProperty = true;
+        property.primitiveType = (0, get_primitive_type_1.getPrimitiveType)(property);
+        property.columnType = (0, get_column_type_1.getColumnType)(property);
+        property.columnName = (0, get_name_by_strategy_1.getNameByStrategy)({
+            name: property.propertyKey,
+            overrideName: options?.name
+        });
+    };
+}

package/database/decorators/index.d.ts

@@ -0,0 +1,13 @@
+export * from './column.decorator';
+export * from './entity.decorator';
+export * from './id-generated.decorator';
+export * from './id.decorator';
+export * from './inject-data-source.decorator';
+export * from './inject-repository.decorator';
+export * from './protect-context-column.decorator';
+export * from './protect-entity.decorator';
+export * from './protect-key-column.decorator';
+export * from './protect-target-column.decorator';
+export * from './protected-entity.decorator';
+export * from './relation.decorator';
+export * from './virtual-column.decorator';

package/database/decorators/index.js

@@ -0,0 +1,29 @@
+"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("./column.decorator"), exports);
+__exportStar(require("./entity.decorator"), exports);
+__exportStar(require("./id-generated.decorator"), exports);
+__exportStar(require("./id.decorator"), exports);
+__exportStar(require("./inject-data-source.decorator"), exports);
+__exportStar(require("./inject-repository.decorator"), exports);
+__exportStar(require("./protect-context-column.decorator"), exports);
+__exportStar(require("./protect-entity.decorator"), exports);
+__exportStar(require("./protect-key-column.decorator"), exports);
+__exportStar(require("./protect-target-column.decorator"), exports);
+__exportStar(require("./protected-entity.decorator"), exports);
+__exportStar(require("./relation.decorator"), exports);
+__exportStar(require("./virtual-column.decorator"), exports);

package/database/decorators/inject-data-source.decorator.d.ts

@@ -0,0 +1 @@
+export declare const InjectDataSource: () => (target: any, propertyKey: string) => void;

package/database/decorators/inject-data-source.decorator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectDataSource = void 0;
+const InjectDataSource = () => {
+    return (target, propertyKey) => {
+        Reflect.defineProperty(target, propertyKey, {
+            get() {
+                return core.database.dataSource;
+            }
+        });
+    };
+};
+exports.InjectDataSource = InjectDataSource;

package/database/decorators/inject-repository.decorator.d.ts

@@ -0,0 +1,2 @@
+import { GetTypeCallback } from "../../common";
+export declare function InjectRepository(type: GetTypeCallback): (target: any, propertyKey: string) => void;

package/database/decorators/inject-repository.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectRepository = InjectRepository;
+const transaction_context_1 = require("../contexts/transaction-context");
+const use_repository_1 = require("../functions/use-repository");
+function InjectRepository(type) {
+    return function (target, propertyKey) {
+        Object.defineProperty(target, propertyKey, {
+            get: () => {
+                const transactionContext = transaction_context_1.transactionContextStore.getStore();
+                return transactionContext?.entityManager
+                    ? transactionContext.entityManager.getRepository(type())
+                    : (0, use_repository_1.useRepository)(type());
+            }
+        });
+    };
+}

package/database/decorators/protect-context-column.decorator.d.ts

@@ -0,0 +1,3 @@
+import { GetTypeCallback } from "../../common";
+import { RelationOptions } from "../interfaces";
+export declare const ProtectContextColumn: (type: GetTypeCallback, options?: RelationOptions) => (target: any, propertyKey: any) => void;

package/database/decorators/protect-context-column.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectContextColumn = void 0;
+const relation_decorator_1 = require("../functions/relation-decorator");
+const ProtectContextColumn = (type, options) => {
+    return (target, propertyKey) => {
+        const property = (0, relation_decorator_1.relationDecorator)(target, propertyKey, type, options);
+        property.isProtectContext = true;
+    };
+};
+exports.ProtectContextColumn = ProtectContextColumn;

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

@@ -0,0 +1,4 @@
+import { IEntityOptions } from "..";
+export interface IProtectEntityOptions extends IEntityOptions {
+}
+export declare const ProtectEntity: (options?: IProtectEntityOptions) => (target: any) => void;

package/database/decorators/protect-entity.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectEntity = void 0;
+const entity_decorator_1 = require("../functions/entity-decorator");
+;
+const ProtectEntity = (options) => {
+    return (target) => {
+        const object = (0, entity_decorator_1.entityDecorator)(target, options);
+        object.isProtect = true;
+    };
+};
+exports.ProtectEntity = ProtectEntity;

package/database/decorators/protect-key-column.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ColumnOptions } from "typeorm/decorator/options/ColumnOptions";
+export declare const ProtectKeyColumn: (options?: ColumnOptions) => (target: any, propertyKey: string) => void;

package/database/decorators/protect-key-column.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectKeyColumn = void 0;
+const column_decorator_1 = require("../functions/column-decorator");
+const ProtectKeyColumn = (options) => {
+    return (target, propertyKey) => {
+        const property = (0, column_decorator_1.columnDecorator)(target, propertyKey, 'varchar', options);
+        property.isProtectKey = true;
+    };
+};
+exports.ProtectKeyColumn = ProtectKeyColumn;

package/database/decorators/protect-target-column.decorator.d.ts

@@ -0,0 +1,3 @@
+import { GetTypeCallback } from "../../common";
+import { RelationOptions } from "../interfaces";
+export declare const ProtectTargetColumn: (type: GetTypeCallback, options?: RelationOptions) => (target: any, propertyKey: string) => void;

package/database/decorators/protect-target-column.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectTargetColumn = void 0;
+const relation_decorator_1 = require("../functions/relation-decorator");
+const ProtectTargetColumn = (type, options) => {
+    return (target, propertyKey) => {
+        const property = (0, relation_decorator_1.relationDecorator)(target, propertyKey, type, options);
+        property.isProtectTarget = true;
+    };
+};
+exports.ProtectTargetColumn = ProtectTargetColumn;

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

@@ -0,0 +1,8 @@
+import { IEntityOptions } from "..";
+import { GetTypeCallback } from "../../common";
+import { IAuthorizationKeys } from "../../security/interfaces/authorization-schema";
+export interface IProtectedEntityOptions extends IEntityOptions {
+    type: GetTypeCallback;
+    keys?: IAuthorizationKeys;
+}
+export declare const ProtectedEntity: (options: IProtectedEntityOptions) => (target: any) => void;

package/database/decorators/protected-entity.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectedEntity = void 0;
+const add_protected_1 = require("../../security/functions/add-protected");
+const entity_decorator_1 = require("../functions/entity-decorator");
+;
+const ProtectedEntity = (options) => {
+    return (target) => {
+        const object = (0, entity_decorator_1.entityDecorator)(target, options);
+        object.protected = options;
+        if (options.keys?.create) {
+            (0, add_protected_1.addProtected)(options.keys.create.protector || options.type, [options.keys.create]);
+        }
+        if (options.keys?.modify) {
+            (0, add_protected_1.addProtected)(options.keys.modify.protector || options.type, [options.keys.modify]);
+        }
+        if (options.keys?.read) {
+            (0, add_protected_1.addProtected)(options.keys.read.protector || options.type, [options.keys.read]);
+        }
+        if (options.keys?.remove) {
+            (0, add_protected_1.addProtected)(options.keys.remove.protector || options.type, [options.keys.remove]);
+        }
+    };
+};
+exports.ProtectedEntity = ProtectedEntity;

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

@@ -0,0 +1,3 @@
+import { RelationOptions } from "../interfaces";
+import { GetTypeCallback } from "../../common";
+export declare const Relation: <T>(type: GetTypeCallback<T>, options?: RelationOptions) => (target: any, propertyKey: string) => void;

package/database/decorators/relation.decorator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Relation = void 0;
+const relation_decorator_1 = require("../functions/relation-decorator");
+const Relation = (type, options) => {
+    return (target, propertyKey) => {
+        const _default = {
+            onUpdate: 'CASCADE'
+        };
+        (0, relation_decorator_1.relationDecorator)(target, propertyKey, type, { ..._default, ...options });
+    };
+};
+exports.Relation = Relation;

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

@@ -0,0 +1,4 @@
+import { VirtualColumn as VirtualColumnTypeorm } from 'typeorm';
+export type VirtualColumnOptions = Parameters<typeof VirtualColumnTypeorm>;
+export declare function VirtualColumn(options: VirtualColumnOptions[1]): any;
+export declare function VirtualColumn(typeOrOptions: VirtualColumnOptions[0], options: VirtualColumnOptions[1]): any;

package/database/decorators/virtual-column.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualColumn = VirtualColumn;
+const typeorm_1 = require("typeorm");
+function VirtualColumn(arg1, arg2) {
+    return function (target, propertyKey) {
+        const property = core
+            .storage
+            .createProperty(target, propertyKey);
+        property.isVirtual = true;
+        if (arg2)
+            (0, typeorm_1.VirtualColumn)(arg1, arg2)(target, propertyKey);
+        else
+            (0, typeorm_1.VirtualColumn)(arg1)(target, propertyKey);
+    };
+}

package/database/environment.d.ts

@@ -0,0 +1,21 @@
+import { RegisterOneToMany } from "./interfaces/register-one-to-many";
+export declare const environment: {
+    nanoIdAlphabet: {
+        urlAlphabet: string;
+        lowerCaseLettersAndDigits: string;
+        lowerCaseLetters: string;
+        letters: string;
+        lettersAndDigits: string;
+        hexadecimalLowerCase: string;
+        hexadecimalUppercase: string;
+        digits: string;
+        noLookAlikes: string;
+        noLookAlikesSafe: string;
+        uppercaseLetters: string;
+        uppercaseLettersAndDigits: string;
+    };
+    uuidVarcharMigration: {
+        database: string;
+    };
+    oneToManyRegistrations: RegisterOneToMany[];
+};

package/database/environment.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environment = void 0;
+const nanoid_1 = require("nanoid");
+const nano_id_alphabet_type_1 = require("./interfaces/enum/nano-id-alphabet-type");
+exports.environment = {
+    nanoIdAlphabet: {
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.urlAlphabet]: nanoid_1.urlAlphabet,
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.lowerCaseLettersAndDigits]: '0123456789abcdefghijklmnopqrstuvwxyz',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.lowerCaseLetters]: 'abcdefghijklmnopqrstuvwxyz',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.letters]: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.lettersAndDigits]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.hexadecimalLowerCase]: '0123456789abcdef',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.hexadecimalUppercase]: '0123456789ABCDEF',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.digits]: '0123456789',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.noLookAlikes]: '346789ABCDEFGHJKLMNPQRTUVWXYabcdefghijkmnpqrtwxyz',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.noLookAlikesSafe]: '6789BCDFGHJKLMNPQRTWbcdfghjkmnpqrtwz',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.uppercaseLetters]: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        [nano_id_alphabet_type_1.NanoIdAlphabetType.uppercaseLettersAndDigits]: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    },
+    uuidVarcharMigration: {
+        database: null
+    },
+    oneToManyRegistrations: []
+};

package/database/exports/index.d.ts

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

package/database/exports/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("./typeorm"), exports);

package/database/exports/typeorm.d.ts

@@ -0,0 +1 @@
+export { UpdateResult, DeleteResult, FindOptionsWhere, FindOptionsOrder, FindOptionsSelect, DataSource, Unique, Index } from 'typeorm';

package/database/exports/typeorm.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Index = exports.Unique = exports.DataSource = exports.DeleteResult = exports.UpdateResult = void 0;
+var typeorm_1 = require("typeorm");
+Object.defineProperty(exports, "UpdateResult", { enumerable: true, get: function () { return typeorm_1.UpdateResult; } });
+Object.defineProperty(exports, "DeleteResult", { enumerable: true, get: function () { return typeorm_1.DeleteResult; } });
+Object.defineProperty(exports, "DataSource", { enumerable: true, get: function () { return typeorm_1.DataSource; } });
+Object.defineProperty(exports, "Unique", { enumerable: true, get: function () { return typeorm_1.Unique; } });
+Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return typeorm_1.Index; } });

package/database/extensions/select-query-builder.d.ts

@@ -0,0 +1,11 @@
+import { SelectQueryBuilder as TSelectQueryBuilder } from 'typeorm';
+type VirtualSelect = {
+    selection: string;
+    alias: string;
+};
+export declare class SelectQueryBuilder<T> extends TSelectQueryBuilder<T> {
+    protected virtualSelect: VirtualSelect[];
+    addVirtualSelect(selection: string, alias: string): this;
+    getVirtualSelect(): VirtualSelect[];
+}
+export {};

package/database/extensions/select-query-builder.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectQueryBuilder = void 0;
+const typeorm_1 = require("typeorm");
+class SelectQueryBuilder extends typeorm_1.SelectQueryBuilder {
+    constructor() {
+        super(...arguments);
+        this.virtualSelect = [];
+    }
+    addVirtualSelect(selection, alias) {
+        this.virtualSelect.pushIfNotExists({
+            selection: selection,
+            alias: alias
+        }, (target, source) => (target.selection === source.selection));
+        return this;
+    }
+    getVirtualSelect() {
+        return this.virtualSelect;
+    }
+}
+exports.SelectQueryBuilder = SelectQueryBuilder;

package/database/functions/column-decorator.d.ts

@@ -0,0 +1,6 @@
+import { ColumnEmbeddedOptions } from "typeorm/decorator/options/ColumnEmbeddedOptions";
+import { PropertyNote } from "@rockster/class-memory";
+import { IEntityProperty } from "..";
+export declare const columnDecorator: (target: any, propertyKey: string, type?: any | ColumnEmbeddedOptions, options?: ColumnEmbeddedOptions & {
+    name?: string;
+}) => PropertyNote<IEntityProperty>;

package/database/functions/column-decorator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.columnDecorator = void 0;
+const register_column_1 = require("./register-column");
+const get_primitive_type_1 = require("./get-primitive-type");
+const get_column_type_1 = require("./get-column-type");
+const get_name_by_strategy_1 = require("./get-name-by-strategy");
+const columnDecorator = (target, propertyKey, type, options) => {
+    const property = core
+        .storage
+        .createProperty(target, propertyKey);
+    property.columnName = (0, get_name_by_strategy_1.getNameByStrategy)({
+        name: propertyKey,
+        overrideName: options?.name
+    });
+    (0, register_column_1.registerColumn)({
+        type,
+        propertyKey,
+        target,
+        options: {
+            ...options,
+            name: property.columnName
+        }
+    });
+    property.primitiveType =
+        (0, get_primitive_type_1.getPrimitiveType)(property);
+    property.columnType =
+        (0, get_column_type_1.getColumnType)(property);
+    return property;
+};
+exports.columnDecorator = columnDecorator;

package/database/functions/create-entity.d.ts

@@ -0,0 +1,7 @@
+import { ColumnDef, IEntityOptions, RelationDef } from "../interfaces";
+export declare const createEntity: ({ name, options, columns, relations }: {
+    name: string;
+    options?: IEntityOptions;
+    columns: ColumnDef[];
+    relations?: RelationDef[];
+}) => any;

package/database/functions/create-entity.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntity = void 0;
+const global_1 = require("../../global");
+const create_new_class_1 = require("./create-new-class");
+const database_controller_1 = require("../database.controller");
+const decorators_1 = require("../decorators");
+const interfaces_1 = require("../interfaces");
+const createEntity = ({ name, options, columns, relations }) => {
+    const classObject = (0, create_new_class_1.createNewClass)(name);
+    for (const column of columns) {
+        Reflect
+            .defineMetadata(global_1.DESIGN_TYPE_KEY, column.designType, classObject.prototype, column.propertyKey);
+        switch (column.defType) {
+            case interfaces_1.ColumnDefType.column:
+                (0, decorators_1.Column)({
+                    ...column.options,
+                    type: column.type
+                })(classObject.prototype, column.propertyKey);
+                break;
+            case interfaces_1.ColumnDefType.generatedId:
+                (0, decorators_1.IdGenerated)(column.strategy, column.options)(classObject.prototype, column.propertyKey);
+                break;
+            case interfaces_1.ColumnDefType.id:
+                (0, decorators_1.Id)(column.type, column.options)(classObject.prototype, column.propertyKey);
+                break;
+        }
+    }
+    for (const relation of relations) {
+        Reflect
+            .defineMetadata(global_1.DESIGN_TYPE_KEY, relation.designType, classObject.prototype, relation.propertyKey);
+        (0, decorators_1.Relation)(relation.type, relation.options)(classObject.prototype, relation.propertyKey);
+        const objectNote = core
+            .storage
+            .findObject(relation.type());
+        if (objectNote) {
+            database_controller_1.DatabaseController
+                ._objects
+                .pushIfNotExists(objectNote);
+        }
+    }
+    (0, decorators_1.Entity)(options)(classObject);
+    const objectNote = core
+        .storage
+        .findObject(classObject);
+    database_controller_1.DatabaseController
+        ._objects
+        .push(objectNote);
+    return classObject;
+};
+exports.createEntity = createEntity;

package/database/functions/create-new-class.d.ts

@@ -0,0 +1 @@
+export declare const createNewClass: (name: string, extendsObject?: any) => any;

package/database/functions/create-new-class.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNewClass = void 0;
+const createNewClass = (name, extendsObject) => {
+    let object;
+    if (extendsObject) {
+        object = { [name]: class extends extendsObject {
+            } };
+    }
+    else {
+        object = { [name]: class {
+            } };
+    }
+    return object[name];
+};
+exports.createNewClass = createNewClass;