@rockster/core 0.0.1

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

@@ -0,0 +1,3 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { IEntityObject, IEntityOptions } from "..";
+export declare function entityDecorator(target: any, options: IEntityOptions): ObjectNote<IEntityObject>;

package/database/functions/entity-decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityDecorator = entityDecorator;
+const register_entity_1 = require("./register-entity");
+const common_1 = require("../../common");
+function entityDecorator(target, options) {
+    const object = core
+        .storage
+        .createObject(target);
+    const { camelCase, snakeCase, } = object
+        .objectKey
+        .getNaming();
+    object.type = common_1.ObjectType.entity;
+    object.tableName = options?.tableName || snakeCase;
+    object.alias = options?.alias || camelCase;
+    object.strict = options?.strict;
+    object.idProperty = core
+        .storage
+        .getProperties(target)
+        .find((property) => {
+        return property.isIdProperty;
+    })
+        ?.propertyKey;
+    (0, register_entity_1.registerEntity)({
+        target,
+        options: { name: object.tableName }
+    });
+    return object;
+}

package/database/functions/execute-if-not-exists-column.d.ts

@@ -0,0 +1,3 @@
+import { QueryRunner } from 'typeorm';
+import { ExecuteCallback } from '../interfaces';
+export declare const executeIfNotExistsColumn: (path: string, queryRunner: QueryRunner, callback: ExecuteCallback) => Promise<void>;

package/database/functions/execute-if-not-exists-column.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeIfNotExistsColumn = void 0;
+const executeIfNotExistsColumn = async (path, queryRunner, callback) => {
+    const [table, column] = path.split('.');
+    const rows = await queryRunner.query(`
+      SELECT * FROM "information_schema"."columns" 
+      WHERE table_name = '${table}' 
+      AND column_name = '${column}'
+   `);
+    const exists = rows[0];
+    if (!exists) {
+        await callback();
+    }
+};
+exports.executeIfNotExistsColumn = executeIfNotExistsColumn;

package/database/functions/execute-if-not-exists-table.d.ts

@@ -0,0 +1,3 @@
+import { QueryRunner } from 'typeorm';
+import { ExecuteCallback } from '../interfaces';
+export declare const executeIfNotExistsTable: (name: string, queryRunner: QueryRunner, callback: ExecuteCallback) => Promise<void>;

package/database/functions/execute-if-not-exists-table.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeIfNotExistsTable = void 0;
+const executeIfNotExistsTable = async (name, queryRunner, callback) => {
+    const rows = await queryRunner.query(`
+      SELECT * FROM "information_schema"."tables" 
+      WHERE table_name = '${name}'
+   `);
+    const exists = rows[0];
+    if (!exists) {
+        await callback();
+    }
+};
+exports.executeIfNotExistsTable = executeIfNotExistsTable;

package/database/functions/find-relation.d.ts

@@ -0,0 +1,3 @@
+import { Instantiable } from "@rockster/common";
+import { RelationPath, RelationPathType } from "..";
+export declare const findRelationPath: (type: RelationPathType, fromEntity: Instantiable, toEntity: Instantiable, propertyName: string) => RelationPath;

package/database/functions/find-relation.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRelationPath = void 0;
+const paths_builder_1 = require("../services/paths-builder");
+const __1 = require("..");
+const findRelationPath = (type, fromEntity, toEntity, propertyName) => {
+    const relation = type === __1.RelationPathType.direct
+        ? findDirectRelation(fromEntity, toEntity, propertyName)
+        : findIndirectRelation(fromEntity, toEntity);
+    if (!relation) {
+        throw new Error(`[${toEntity.name}] does not have connection with [${fromEntity.name}]`);
+    }
+    return relation;
+};
+exports.findRelationPath = findRelationPath;
+const findDirectRelation = (fromEntity, toEntity, propertyName) => {
+    return paths_builder_1.PathsBuilder
+        .relationsPaths
+        .find((relation) => {
+        return !relation.parent
+            && relation.object.objectClass === fromEntity
+            && relation.property.getRelationType() === toEntity
+            && relation.property.directAlias === propertyName;
+    });
+};
+const findIndirectRelation = (fromEntity, toEntity) => {
+    return paths_builder_1.PathsBuilder
+        .relationsPaths
+        .find((relation) => {
+        return relation
+            .property
+            .getRelationType() === fromEntity
+            && relation.property.objectClass === toEntity
+            && hasConnection(relation, fromEntity)
+            && relation.type === __1.RelationPathType.indirect;
+    });
+};
+const hasConnection = (relationPath, entity) => {
+    if (relationPath.parent) {
+        return hasConnection(relationPath.parent, entity);
+    }
+    return relationPath.object.objectClass === entity;
+};

package/database/functions/generate-id.d.ts

@@ -0,0 +1,2 @@
+import { EntityTarget } from "typeorm";
+export default function generateId<T>(target: EntityTarget<T>, data?: T): string;

package/database/functions/generate-id.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateId;
+const get_id_property_1 = require("./get-id-property");
+function generateId(target, data) {
+    const idProperty = (0, get_id_property_1.getIdProperty)(target);
+    let idValue = idProperty.getNewId();
+    if (!data)
+        return idValue;
+    if (!data[idProperty.propertyKey]) {
+        data[idProperty.propertyKey] = idValue;
+    }
+    return idValue;
+}

package/database/functions/get-column-type.d.ts

@@ -0,0 +1,3 @@
+import { PropertyNote } from "@rockster/class-memory";
+import { IEntityProperty } from "..";
+export declare function getColumnType(property: PropertyNote<IEntityProperty>): any;

package/database/functions/get-column-type.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnType = getColumnType;
+function getColumnType(property) {
+    const typeOrmStorage = global
+        .typeormMetadataArgsStorage;
+    const column = typeOrmStorage
+        .columns
+        .find((column) => {
+        return column.target === property.objectClass
+            && column.propertyName === property.propertyKey;
+    });
+    const type = column?.options?.type;
+    return typeof type === 'function'
+        || typeof type === 'object'
+        ? type?.name
+        : type;
+}

package/database/functions/get-id-property.d.ts

@@ -0,0 +1,3 @@
+import { PropertyNote } from "@rockster/class-memory";
+import { IEntityProperty } from "..";
+export declare const getIdProperty: (entity: any) => PropertyNote<IEntityProperty>;

package/database/functions/get-id-property.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdProperty = void 0;
+const getIdProperty = (entity) => {
+    const properties = core
+        .storage
+        .getProperties(entity);
+    const idProperty = properties
+        .find((property) => {
+        return property.isIdProperty;
+    });
+    return idProperty;
+};
+exports.getIdProperty = getIdProperty;

package/database/functions/get-name-by-strategy.d.ts

@@ -0,0 +1,6 @@
+type GetNameByStrategy = {
+    overrideName?: string;
+    name?: string;
+};
+export declare function getNameByStrategy({ name, overrideName }: GetNameByStrategy): string;
+export {};

package/database/functions/get-name-by-strategy.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNameByStrategy = getNameByStrategy;
+function getNameByStrategy({ name, overrideName }) {
+    if (overrideName)
+        return overrideName;
+    const naming = name.getNaming(name);
+    return naming.snakeCase;
+}

package/database/functions/get-primitive-type.d.ts

@@ -0,0 +1,3 @@
+import { PropertyNote } from "@rockster/class-memory";
+import { IEntityProperty } from "..";
+export declare function getPrimitiveType(property: PropertyNote<IEntityProperty>): any;

package/database/functions/get-primitive-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrimitiveType = getPrimitiveType;
+function getPrimitiveType(property) {
+    return property
+        .metadata["design:type"]
+        ?.name;
+}

package/database/functions/get-relations.d.ts

@@ -0,0 +1,2 @@
+import { IEntityProperty } from "..";
+export declare const getRelations: (target: any) => import("@rockster/class-memory").PropertyNote<IEntityProperty>[];

package/database/functions/get-relations.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelations = void 0;
+const getRelations = (target) => {
+    return core
+        .storage
+        .getProperties(target)
+        .filter((property) => {
+        return property.isRelation;
+    });
+};
+exports.getRelations = getRelations;

package/database/functions/has-update.d.ts

@@ -0,0 +1,2 @@
+import { DeleteResult, UpdateResult } from "typeorm";
+export declare const hasUpdate: (result: UpdateResult | DeleteResult) => boolean;

package/database/functions/has-update.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasUpdate = void 0;
+const hasUpdate = (result) => {
+    return result.affected >= 1;
+};
+exports.hasUpdate = hasUpdate;

package/database/functions/inject-repository-handle.d.ts

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

package/database/functions/inject-repository-handle.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectRepositoryHandle = injectRepositoryHandle;
+const use_repository_1 = require("./use-repository");
+const transaction_context_1 = require("../contexts/transaction-context");
+function injectRepositoryHandle(type, target, propertyKey) {
+    let _value = undefined;
+    Reflect.defineProperty(target, propertyKey, {
+        get() {
+            return core.database?.dataSource
+                ? new Proxy((0, use_repository_1.useRepository)(type()), {
+                    get: (target, property) => {
+                        switch (property) {
+                            case 'target':
+                            case 'queryRunner':
+                            case 'metadata':
+                            case 'manager':
+                                return target[property];
+                            default:
+                                return (_, ...args) => {
+                                    const currentStore = transaction_context_1.transactionContextStore.getStore();
+                                    const repository = currentStore?.entityManager
+                                        ? currentStore?.entityManager.getRepository(type())
+                                        : target;
+                                    return repository[property]?.apply(repository, [...args]);
+                                };
+                        }
+                    }
+                })
+                : _value;
+        },
+        set(value) {
+            _value = value;
+        }
+    });
+}

package/database/functions/object-to-jsonb.d.ts

@@ -0,0 +1 @@
+export declare const objectToJsonb: (value: any, property?: string, parent?: string) => string;

package/database/functions/object-to-jsonb.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToJsonb = void 0;
+const objectToJsonb = (value, property, parent = '') => {
+    const properties = Object
+        .getOwnPropertyNames(value);
+    const marker = '{json}';
+    let update = marker;
+    for (const propertyName of properties) {
+        const propertyValue = value[propertyName];
+        if (typeof propertyValue === 'object') {
+            update = update
+                .replace(marker, (0, exports.objectToJsonb)(propertyValue, undefined, `${propertyName},`));
+        }
+        else {
+            const jsonbSet = `jsonb_set(${marker}, '{${parent}${propertyName}}', to_jsonb(${getValue(propertyValue)}))`;
+            update = update.replace(marker, jsonbSet);
+        }
+    }
+    if (property) {
+        update = update
+            .replace(marker, `to_jsonb("${property}")`);
+    }
+    return update;
+};
+exports.objectToJsonb = objectToJsonb;
+const getValue = (value) => {
+    switch (typeof value) {
+        case "bigint":
+        case "boolean":
+        case "number":
+            return `${value}`;
+        default:
+            return `"${value}"`;
+    }
+};

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

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

package/database/functions/register-column.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerColumn = void 0;
+const lodash_1 = require("lodash");
+const typeorm_1 = require("typeorm");
+const registerColumn = ({ propertyKey, target, options, type }) => {
+    const columnType = ((0, lodash_1.isString)(type)
+        ? type
+        : type?.type ?? options?.type);
+    (0, typeorm_1.Column)({
+        ...options,
+        ...(0, lodash_1.isObject)(type) ? type : {},
+        type: columnType
+    })(target, propertyKey);
+};
+exports.registerColumn = registerColumn;

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

@@ -0,0 +1,5 @@
+import { EntityOptions } from "typeorm";
+export declare const registerEntity: ({ target, options }: {
+    target: any;
+    options?: EntityOptions;
+}) => void;

package/database/functions/register-entity.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEntity = void 0;
+const typeorm_1 = require("typeorm");
+const registerEntity = ({ target, options }) => {
+    (0, typeorm_1.Entity)(options)(target);
+};
+exports.registerEntity = registerEntity;

package/database/functions/register-generated-id.d.ts

@@ -0,0 +1,6 @@
+export declare const registerGeneratedId: ({ strategy, propertyKey, target, options }: {
+    strategy?: any;
+    options?: any;
+    target: any;
+    propertyKey: string;
+}) => void;

package/database/functions/register-generated-id.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGeneratedId = void 0;
+const typeorm_1 = require("typeorm");
+const registerGeneratedId = ({ strategy, propertyKey, target, options }) => {
+    (0, typeorm_1.PrimaryGeneratedColumn)(strategy, options)(target, propertyKey);
+};
+exports.registerGeneratedId = registerGeneratedId;

package/database/functions/register-id.d.ts

@@ -0,0 +1,7 @@
+import { PrimaryColumnOptions } from "typeorm";
+export declare const registerId: ({ target, propertyKey, type, options }: {
+    target: any;
+    propertyKey: string;
+    type?: any;
+    options?: PrimaryColumnOptions;
+}) => void;

package/database/functions/register-id.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerId = void 0;
+const typeorm_1 = require("typeorm");
+const registerId = ({ target, propertyKey, type, options }) => {
+    (0, typeorm_1.PrimaryColumn)(type, options)(target, propertyKey);
+};
+exports.registerId = registerId;

package/database/functions/register-relation.d.ts

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

package/database/functions/register-relation.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRelation = void 0;
+const typeorm_1 = require("typeorm");
+const registerRelation = ({ type, options, directAlias, target }) => {
+    (0, typeorm_1.ManyToOne)(type, options)(target, directAlias);
+    (0, typeorm_1.JoinColumn)({
+        name: options.name,
+        referencedColumnName: options?.referencedColumnName
+    })(target, directAlias);
+};
+exports.registerRelation = registerRelation;

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

@@ -0,0 +1,4 @@
+import { PropertyNote } from "@rockster/class-memory";
+import { IEntityProperty, RelationOptions } from "..";
+import { GetTypeCallback } from "../../common";
+export declare const relationDecorator: <T>(target: any, propertyKey: string, type: GetTypeCallback<T>, options?: RelationOptions) => PropertyNote<IEntityProperty>;

package/database/functions/relation-decorator.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationDecorator = void 0;
+const get_primitive_type_1 = require("./get-primitive-type");
+const register_column_1 = require("./register-column");
+const register_relation_1 = require("./register-relation");
+const get_name_by_strategy_1 = require("./get-name-by-strategy");
+const environment_1 = require("../environment");
+const inflection_1 = require("inflection");
+const typeorm_1 = require("typeorm");
+const relationDecorator = (target, propertyKey, type, options) => {
+    const property = core
+        .storage
+        .createProperty(target, propertyKey);
+    property.primitiveType =
+        (0, get_primitive_type_1.getPrimitiveType)(property);
+    property.isRelation = true;
+    property.getRelationType = type;
+    property.directAlias = options?.directAlias
+        ? options.directAlias()
+        : propertyKey.replace(/id/ig, '');
+    property.columnName = (0, get_name_by_strategy_1.getNameByStrategy)({
+        name: propertyKey,
+        overrideName: options?.name,
+    });
+    environment_1.environment.oneToManyRegistrations.push({
+        type: type,
+        handle: () => {
+            const RelationType = type();
+            const objectNote = core
+                .storage
+                .findObject(target.constructor);
+            if (!objectNote) {
+                return;
+            }
+            const foreignProperties = core
+                .storage
+                .getProperties(RelationType);
+            const idColumn = foreignProperties
+                .find((property) => {
+                return property.isIdProperty;
+            });
+            property.columnType = idColumn.columnType;
+            property.inverseAlias = !property.inverseAlias
+                ? {
+                    alias: objectNote.alias,
+                    mapTo: (0, inflection_1.pluralize)(objectNote.alias)
+                }
+                : property.inverseAlias;
+            (0, typeorm_1.OneToMany)(() => {
+                return target.constructor;
+            }, relation => {
+                return relation[property.directAlias];
+            })(RelationType.prototype, property.inverseAlias.mapTo);
+        }
+    });
+    const optionsWithName = {
+        ...options,
+        name: property.columnName
+    };
+    (0, register_column_1.registerColumn)({
+        propertyKey: propertyKey,
+        target,
+        options: optionsWithName
+    });
+    (0, register_relation_1.registerRelation)({
+        directAlias: property.directAlias,
+        target,
+        type,
+        options: optionsWithName
+    });
+    return property;
+};
+exports.relationDecorator = relationDecorator;

package/database/functions/use-protector.d.ts

@@ -0,0 +1,2 @@
+import { Instantiable } from "@rockster/common";
+export declare const useProtector: (target: Instantiable) => import("../interfaces").Protector;

package/database/functions/use-protector.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProtector = void 0;
+const useProtector = (target) => {
+    const object = core
+        .storage
+        .findObject(target);
+    return object.protector;
+};
+exports.useProtector = useProtector;

package/database/functions/use-repository.d.ts

@@ -0,0 +1,2 @@
+import { EntityTarget } from "typeorm";
+export declare const useRepository: <T>(target: EntityTarget<T>) => import("typeorm").Repository<T>;

package/database/functions/use-repository.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRepository = void 0;
+const useRepository = (target) => {
+    return core
+        ?.database
+        ?.dataSource
+        ?.getRepository(target);
+};
+exports.useRepository = useRepository;

package/database/functions/use-transaction.d.ts

@@ -0,0 +1 @@
+export declare const useTransaction: () => boolean;

package/database/functions/use-transaction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTransaction = void 0;
+const useTransaction = () => {
+    const transaction = core
+        .options
+        .transaction;
+    return !isNullOrUndefined(transaction)
+        ? transaction
+        : true;
+};
+exports.useTransaction = useTransaction;

package/database/index.d.ts

@@ -0,0 +1,16 @@
+export * from './decorators';
+export * from './interfaces';
+export * from './database.controller';
+export * from './extensions/select-query-builder';
+export * from './exports';
+export * from './functions/has-update';
+export * from './functions/get-id-property';
+export * from './functions/object-to-jsonb';
+export * from './functions/find-relation';
+export * from './functions/get-relations';
+export * from './functions/use-transaction';
+export * from './functions/execute-if-not-exists-column';
+export * from './functions/execute-if-not-exists-table';
+export * from './services/repository.service';
+export * from './migrations/use-uuid-varchar-migration';
+export * from './contexts/transaction-context';

package/database/index.js

@@ -0,0 +1,32 @@
+"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("./decorators"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./database.controller"), exports);
+__exportStar(require("./extensions/select-query-builder"), exports);
+__exportStar(require("./exports"), exports);
+__exportStar(require("./functions/has-update"), exports);
+__exportStar(require("./functions/get-id-property"), exports);
+__exportStar(require("./functions/object-to-jsonb"), exports);
+__exportStar(require("./functions/find-relation"), exports);
+__exportStar(require("./functions/get-relations"), exports);
+__exportStar(require("./functions/use-transaction"), exports);
+__exportStar(require("./functions/execute-if-not-exists-column"), exports);
+__exportStar(require("./functions/execute-if-not-exists-table"), exports);
+__exportStar(require("./services/repository.service"), exports);
+__exportStar(require("./migrations/use-uuid-varchar-migration"), exports);
+__exportStar(require("./contexts/transaction-context"), exports);

package/database/interfaces/base-columns-name-override.d.ts

@@ -0,0 +1,6 @@
+export type BaseColumnNamesOverride = {
+    lastModifiedAtColumn: string;
+    lastModifiedByColumn: string;
+    createdByColumn: string;
+    createdAtColumn: string;
+};

package/database/interfaces/base-columns-name-override.js

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