@rockster/core 0.0.1

package/database/migrations/1737637321043-UUIDVarcharMigration.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UUIDVarcharMigration1737637321043 = void 0;
+const environment_1 = require("../environment");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+class UUIDVarcharMigration1737637321043 {
+    async up(queryRunner) {
+        const drops = [];
+        const changeIds = [];
+        const recreates = [];
+        const database = environment_1.environment
+            .uuidVarcharMigration
+            .database;
+        const tablesQuery = `
+         SELECT 
+               table_catalog, 
+               table_schema, 
+               table_name 
+         FROM information_schema.tables 
+         WHERE table_catalog = '${database}'
+            AND table_schema = 'public' 
+            AND table_name <> 'migrations';
+        `;
+        const columnsQuery = (table) => `
+         SELECT
+            table_name,
+            table_catalog,
+            table_schema,
+            column_name,
+            udt_name
+         FROM information_schema.columns
+         WHERE table_catalog = '${database}'
+            AND table_schema = 'public'
+            AND table_name = '${table}'
+            AND udt_name = 'uuid';
+      `;
+        const foreignKeysQuery = (table) => `
+         SELECT conrelid::regclass AS table_name,
+               conname AS foreign_key,
+               pg_get_constraintdef(oid) as foreign_key_def
+         FROM   pg_constraint 
+         WHERE  contype = 'f' 
+         AND    connamespace = 'public'::regnamespace   
+         ORDER  BY conrelid::regclass::text, contype DESC;
+      `;
+        const tables = await queryRunner
+            .query(tablesQuery);
+        for (const table of tables) {
+            const columns = await queryRunner.query(columnsQuery(table.table_name));
+            const foreignKeys = await queryRunner.query(foreignKeysQuery(table.table_name));
+            for (const foreignKey of foreignKeys) {
+                drops.pushIfNotExists(`alter table public.${foreignKey.table_name} drop constraint "${foreignKey.foreign_key}";`);
+                recreates.pushIfNotExists(`alter table public.${foreignKey.table_name} add constraint "${foreignKey.foreign_key}" ${foreignKey.foreign_key_def};`);
+            }
+            for (const column of columns) {
+                changeIds.push(`alter table public."${table.table_name}" alter column "${column.column_name}" type varchar using "${column.column_name}"::varchar;`);
+            }
+        }
+        let commands = ``;
+        drops.forEach((drop) => commands += `${drop}\n`);
+        changeIds.forEach((changeId) => commands += `${changeId}\n`);
+        recreates.forEach((recreate) => commands += `${recreate}\n`);
+        (0, fs_1.writeFileSync)(path_1.default.join(process.cwd(), 'uuid_varchar_migration.sql'), commands);
+        for (const drop of drops) {
+            await queryRunner.query(drop);
+        }
+        for (const changeId of changeIds) {
+            await queryRunner.query(changeId);
+        }
+        for (const recreate of recreates) {
+            await queryRunner.query(recreate);
+        }
+    }
+    async down(queryRunner) {
+    }
+}
+exports.UUIDVarcharMigration1737637321043 = UUIDVarcharMigration1737637321043;

package/database/migrations/use-uuid-varchar-migration.d.ts

@@ -0,0 +1,2 @@
+import { UUIDVarcharMigration1737637321043 } from "./1737637321043-UUIDVarcharMigration";
+export declare const useUUIDVarcharMigration: (database: string) => typeof UUIDVarcharMigration1737637321043;

package/database/migrations/use-uuid-varchar-migration.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUUIDVarcharMigration = void 0;
+const environment_1 = require("../environment");
+const _1737637321043_UUIDVarcharMigration_1 = require("./1737637321043-UUIDVarcharMigration");
+const useUUIDVarcharMigration = (database) => {
+    environment_1.environment.uuidVarcharMigration.database = database;
+    return _1737637321043_UUIDVarcharMigration_1.UUIDVarcharMigration1737637321043;
+};
+exports.useUUIDVarcharMigration = useUUIDVarcharMigration;

package/database/services/paths-builder.d.ts

@@ -0,0 +1,12 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { IEntityObject, IEntityProperty, RelationPath, RelationPathType } from "../interfaces";
+export declare class PathsBuilder {
+    static relationsPaths: RelationPath[];
+    protected get relations(): RelationPath[];
+    build(object: ObjectNote<IEntityObject>): Promise<void>;
+    protected buildRelations(parentPath: RelationPath, object: ObjectNote<IEntityObject>): void;
+    protected createRelations(type: RelationPathType, parentPath: RelationPath, object: ObjectNote<IEntityObject>, properties: PropertyNote<IEntityProperty>[]): void;
+    protected getDirectRelations(object: ObjectNote<IEntityObject>): PropertyNote<IEntityProperty>[];
+    protected getIndirectRelations(object: ObjectNote<IEntityObject>): PropertyNote<IEntityProperty>[];
+    protected getIsRecursive(relationPath: RelationPath, object: ObjectNote<IEntityObject>): any;
+}

package/database/services/paths-builder.js

@@ -0,0 +1,82 @@
+"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 PathsBuilder_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathsBuilder = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const interfaces_1 = require("../interfaces");
+let PathsBuilder = PathsBuilder_1 = class PathsBuilder {
+    get relations() {
+        return PathsBuilder_1.relationsPaths;
+    }
+    async build(object) {
+        this.buildRelations(null, object);
+    }
+    buildRelations(parentPath, object) {
+        const direct = this.getDirectRelations(object);
+        const indirect = this.getIndirectRelations(object);
+        this.createRelations(interfaces_1.RelationPathType.direct, parentPath, object, direct);
+        this.createRelations(interfaces_1.RelationPathType.indirect, parentPath, object, indirect);
+    }
+    createRelations(type, parentPath, object, properties) {
+        for (const property of properties) {
+            const relationObject = core
+                .storage
+                .findObject(property.getRelationType());
+            const relation = {
+                type: type,
+                parent: parentPath,
+                object: object,
+                property: property,
+                recursive: false
+            };
+            this.relations.push(relation);
+            const isRecursive = this
+                .getIsRecursive(relation, relationObject);
+            if (!isRecursive) {
+                this.buildRelations(relation, relationObject);
+            }
+            else {
+                relation.recursive = true;
+            }
+        }
+    }
+    getDirectRelations(object) {
+        return core
+            .storage
+            .getProperties(object.objectClass)
+            .filter((property) => {
+            return property.getRelationType;
+        });
+    }
+    getIndirectRelations(object) {
+        return core
+            .storage
+            .getProperties()
+            .filter((property) => {
+            return property.getRelationType
+                && property.getRelationType() === object.objectClass;
+        });
+    }
+    getIsRecursive(relationPath, object) {
+        if (!object) {
+            throw new Error(`Entity metadata not found for: ${relationPath.object.alias}.${relationPath.property.propertyKey}`);
+        }
+        if (relationPath.object.objectClass === object.objectClass) {
+            return relationPath;
+        }
+        if (relationPath.parent) {
+            return this.getIsRecursive(relationPath.parent, object);
+        }
+    }
+};
+exports.PathsBuilder = PathsBuilder;
+PathsBuilder.relationsPaths = [];
+exports.PathsBuilder = PathsBuilder = PathsBuilder_1 = __decorate([
+    (0, class_injector_1.Injectable)()
+], PathsBuilder);

package/database/services/protect-builder.d.ts

@@ -0,0 +1,59 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { IEntityObject, IEntityProperty } from "../interfaces";
+import { Dictionary, Instantiable } from "@rockster/common";
+import { IProtectedEntityOptions } from "..";
+import { EntityManager } from "typeorm";
+import { GetUserPermissionsHandle, SetUserPermissionsHandle } from "../interfaces/protector";
+type ProtectedData = {
+    object: ObjectNote<IEntityObject>;
+    context?: PropertyNote<IEntityProperty>;
+    options?: IProtectedEntityOptions;
+    isContext: boolean;
+};
+type ProtectorData = {
+    object: ObjectNote<IEntityObject>;
+    target: PropertyNote<IEntityProperty>;
+    context?: PropertyNote<IEntityProperty>;
+    key?: PropertyNote<IEntityProperty>;
+};
+export declare class ProtectBuilder {
+    build(object: ObjectNote<IEntityObject>): Promise<void>;
+    protected buildProtectorConfig(object: ObjectNote<IEntityObject>): void;
+    protected getRepository(target: Instantiable, entityManager?: EntityManager): import("typeorm").Repository<any>;
+    protected createQueryBuilder({ authKeys, data, protectorData, userId, displayContext, entityManager, protectedData }: {
+        protectorData: ProtectorData;
+        userId: string;
+        data: any;
+        authKeys: string[];
+        displayContext?: string;
+        entityManager?: EntityManager;
+        protectedData?: ProtectedData;
+    }): import("typeorm").SelectQueryBuilder<any>;
+    protected buildFilterKeys(protectorAlias: string, protectorKey: string, keys: string[]): string;
+    protected getQueryContextAndKeyCondition(protectorData: ProtectorData, protectedData: ProtectedData, protectorAlias: string, alias: string, contextParams: Dictionary<any>, rootPath?: Instantiable): {
+        context: string;
+        key: string;
+    };
+    protected buildProtectedConfig(object: ObjectNote<IEntityObject>): void;
+    protected getSetUserPermissions(data: ProtectorData): SetUserPermissionsHandle;
+    protected getGetUserPermissions(data: ProtectorData): GetUserPermissionsHandle;
+    protected getAuthContextFilter(targetUserId: string, data: ProtectorData, contextId: string): {
+        where: {
+            [x: string]: string;
+        };
+        keyProperty: PropertyNote<IEntityProperty>;
+        contextProperty: PropertyNote<IEntityProperty>;
+        targetProperty: PropertyNote<IEntityProperty>;
+    };
+    protected checkIsAuthorized({ data, userId, entityManager, keys, context, contextId }: {
+        data: ProtectorData;
+        entityManager?: EntityManager;
+        keys: string[];
+        context: string;
+        contextId: string;
+        userId: string;
+    }): Promise<void>;
+    protected getProtectedData(protector: ProtectorData, object: ObjectNote<IEntityObject>): ProtectedData;
+    protected getProtectorData(protector: Instantiable): ProtectorData;
+}
+export {};