@elsikora/nestjs-crud-automator/dist/cjs/utility/generate-entity-information.utility.js

A library for automating the creation of CRUD operations in NestJS.

'use strict';

var metadataStorage_class = require('../class/metadata-storage.class.js');
var errorException_utility = require('./error-exception.utility.js');
var typeorm = require('typeorm');

/**
 * Generates metadata information about an entity including columns, table name, and primary key
 * @param {IApiBaseEntity} entity - The entity to generate information for
 * @returns {IApiEntity<E>} The generated entity information object
 * @template E - The entity type
 */
function GenerateEntityInformation(entity) {
    const generatedEntity = {
        columns: [],
        name: "",
        primaryKey: undefined,
        tableName: "",
    };
    generatedEntity.tableName = (() => {
        // eslint-disable-next-line @elsikora/typescript/no-unsafe-function-type
        const table = typeorm.getMetadataArgsStorage().tables.find(({ target }) => target.name === entity.name);
        if (!table) {
            throw errorException_utility.ErrorException(`Table for entity ${String(entity.name)} not found in metadata storage`);
        }
        const namingStrategy = (tableName) => new typeorm.DefaultNamingStrategy().tableName(entity.name ?? "UnknownResource", tableName);
        if (!table.name && table.type === "entity-child") {
            const discriminatorValue = typeorm.getMetadataArgsStorage().discriminatorValues.find(({ target }) => target == entity);
            if (!discriminatorValue?.value) {
                throw errorException_utility.ErrorException(`Discriminator value for entity ${String(entity.name)} not found in metadata storage`);
            }
            else if (typeof discriminatorValue.value === "string") {
                return namingStrategy(discriminatorValue.value);
            }
            else {
                // eslint-disable-next-line @elsikora/typescript/no-unsafe-argument,@elsikora/typescript/no-unsafe-member-access
                return namingStrategy(discriminatorValue.value?.name);
            }
        }
        return namingStrategy(table.name);
    })();
    generatedEntity.name = entity.name;
    const storage = metadataStorage_class.MetadataStorage.getInstance();
    // eslint-disable-next-line @elsikora/typescript/no-unsafe-function-type
    const columnList = typeorm.getMetadataArgsStorage().columns.filter(({ target }) => target.name === entity.name);
    // eslint-disable-next-line @elsikora/typescript/no-unsafe-function-type
    const relationList = typeorm.getMetadataArgsStorage().relations.filter(({ target }) => target.name === entity.name);
    const entityColumns = [
        ...columnList.map(({ options, propertyName }) => ({
            isPrimary: Boolean(options.primary),
            metadata: storage.getMetadata(entity.name ?? "UnknownResource", propertyName) || undefined,
            name: propertyName,
            // eslint-disable-next-line @elsikora/typescript/no-non-null-assertion
            type: options.type,
        })),
        ...relationList.map(({ propertyName, relationType }) => ({
            isPrimary: false,
            metadata: storage.getMetadata(entity.name ?? "UnknownResource", propertyName) || undefined,
            name: propertyName,
            type: relationType,
        })),
    ];
    for (const column of entityColumns) {
        if (column.isPrimary) {
            generatedEntity.primaryKey = column;
        }
    }
    generatedEntity.columns = entityColumns;
    return generatedEntity;
}

exports.GenerateEntityInformation = GenerateEntityInformation;
//# sourceMappingURL=generate-entity-information.utility.js.map