ConnectionMetadataBuilder.ts

import { importClassesFromDirectories } from "../util/DirectoryExportedClassesLoader"
import { OrmUtils } from "../util/OrmUtils"
import { getFromContainer } from "../container"
import { MigrationInterface } from "../migration/MigrationInterface"
import { getMetadataArgsStorage } from "../globals"
import { EntityMetadataBuilder } from "../metadata-builder/EntityMetadataBuilder"
import { EntitySchemaTransformer } from "../entity-schema/EntitySchemaTransformer"
import { DataSource } from "../data-source/DataSource"
import { EntitySchema } from "../entity-schema/EntitySchema"
import { EntityMetadata } from "../metadata/EntityMetadata"
import { EntitySubscriberInterface } from "../subscriber/EntitySubscriberInterface"
import { InstanceChecker } from "../util/InstanceChecker"

/**
 * Builds migration instances, subscriber instances and entity metadatas for the given classes.
 */
export class ConnectionMetadataBuilder {
    // -------------------------------------------------------------------------
    // Constructor
    // -------------------------------------------------------------------------

    constructor(protected connection: DataSource) {}

    // -------------------------------------------------------------------------
    // Public Methods
    // -------------------------------------------------------------------------

    /**
     * Builds migration instances for the given classes or directories.
     */
    async buildMigrations(
        migrations: (Function | string)[],
    ): Promise<MigrationInterface[]> {
        const [migrationClasses, migrationDirectories] =
            OrmUtils.splitClassesAndStrings(migrations)
        const allMigrationClasses = [
            ...migrationClasses,
            ...(await importClassesFromDirectories(
                this.connection.logger,
                migrationDirectories,
            )),
        ]
        return allMigrationClasses.map((migrationClass) =>
            getFromContainer<MigrationInterface>(migrationClass),
        )
    }

    /**
     * Builds subscriber instances for the given classes or directories.
     */
    async buildSubscribers(
        subscribers: (Function | string)[],
    ): Promise<EntitySubscriberInterface<any>[]> {
        const [subscriberClasses, subscriberDirectories] =
            OrmUtils.splitClassesAndStrings(subscribers || [])
        const allSubscriberClasses = [
            ...subscriberClasses,
            ...(await importClassesFromDirectories(
                this.connection.logger,
                subscriberDirectories,
            )),
        ]
        return getMetadataArgsStorage()
            .filterSubscribers(allSubscriberClasses)
            .map((metadata) =>
                getFromContainer<EntitySubscriberInterface<any>>(
                    metadata.target,
                ),
            )
    }

    /**
     * Builds entity metadatas for the given classes or directories.
     */
    async buildEntityMetadatas(
        entities: (Function | EntitySchema<any> | string)[],
    ): Promise<EntityMetadata[]> {
        // todo: instead we need to merge multiple metadata args storages

        const [entityClassesOrSchemas, entityDirectories] =
            OrmUtils.splitClassesAndStrings(entities || [])
        const entityClasses: Function[] = entityClassesOrSchemas.filter(
            (entityClass) => !InstanceChecker.isEntitySchema(entityClass),
        ) as any
        const entitySchemas: EntitySchema<any>[] =
            entityClassesOrSchemas.filter((entityClass) =>
                InstanceChecker.isEntitySchema(entityClass),
            ) as any

        const allEntityClasses = [
            ...entityClasses,
            ...(await importClassesFromDirectories(
                this.connection.logger,
                entityDirectories,
            )),
        ]
        allEntityClasses.forEach((entityClass) => {
            // if we have entity schemas loaded from directories
            if (InstanceChecker.isEntitySchema(entityClass)) {
                entitySchemas.push(entityClass)
            }
        })
        const decoratorEntityMetadatas = new EntityMetadataBuilder(
            this.connection,
            getMetadataArgsStorage(),
        ).build(allEntityClasses)

        const metadataArgsStorageFromSchema =
            new EntitySchemaTransformer().transform(entitySchemas)
        const schemaEntityMetadatas = new EntityMetadataBuilder(
            this.connection,
            metadataArgsStorageFromSchema,
        ).build()

        return [...decoratorEntityMetadatas, ...schemaEntityMetadatas]
    }
}