@energica-city/shared-amplify-utils/dist/middleware/graphql/GraphQLModelInitializer.js

Shared utilities for AWS Amplify projects

import { throwError } from '../../error';
import { ClientManager } from '../../queries/ClientManager';
import { logger } from '../../log';
const modelsCache = new Map();
const initializationPromises = new Map();
function createCacheKey(clientKey, entities) {
    const entityKey = entities ? [...entities].sort().join(',') : 'all';
    return `${clientKey}-${entityKey}`;
}
async function initializeModelsWithTimeout(config) {
    const { schema, amplifyOutputs, entities, clientKey = 'default', timeout = 5000, cache, } = config;
    logger.info('Starting GraphQL model initialization', {
        clientKey,
        entities: entities || 'all',
        timeout,
        cacheEnabled: !!cache?.enabled,
        schemaModels: Object.keys(schema?.models || {}),
        middleware: 'GraphQLModelInitializer',
    });
    const initPromise = ClientManager.initializeQueries({
        schema,
        amplifyOutputs,
        entities,
        clientKey,
        cache,
    });
    const timeoutPromise = new Promise((_, reject) => {
        setTimeout(() => {
            reject(new Error(`Model initialization timeout after ${timeout}ms`));
        }, timeout);
    });
    try {
        const models = await Promise.race([initPromise, timeoutPromise]);
        logger.info('Model initialization completed successfully', {
            initializedModels: Object.keys(models || {}),
            modelCount: Object.keys(models || {}).length,
            clientKey,
            middleware: 'GraphQLModelInitializer',
        });
        return models;
    }
    catch (error) {
        logger.error('Model initialization failed', {
            error: error instanceof Error ? error.message : String(error),
            clientKey,
            entities: entities || 'all',
            timeout,
            cacheEnabled: !!cache?.enabled,
            middleware: 'GraphQLModelInitializer',
        });
        throwError('GraphQL model initialization failed', {
            originalError: error,
            clientKey,
            entities: entities || 'all',
            timeout,
            cacheEnabled: !!cache?.enabled,
        });
    }
}
export function createGraphQLModelInitializer(config) {
    const { clientKey = 'default', entities } = config;
    const cacheKey = createCacheKey(clientKey, entities);
    logger.debug('Creating GraphQL model initializer middleware', {
        clientKey,
        entities: entities || 'all',
        cacheKey,
        middleware: 'GraphQLModelInitializer',
    });
    return async (input, next) => {
        logger.debug('GraphQL model initializer middleware execution started', {
            cacheKey,
            hasModels: !!input.models,
            availableModels: Object.keys(input.models || {}),
            middleware: 'GraphQLModelInitializer',
        });
        let models;
        try {
            models = modelsCache.get(cacheKey);
            if (!models) {
                let initPromise = initializationPromises.get(cacheKey);
                if (!initPromise) {
                    logger.info('Starting new model initialization', {
                        cacheKey,
                        middleware: 'GraphQLModelInitializer',
                    });
                    initPromise = initializeModelsWithTimeout(config);
                    initializationPromises.set(cacheKey, initPromise);
                }
                else {
                    // Wait for existing initialization
                }
                try {
                    models = (await initPromise);
                    modelsCache.set(cacheKey, models);
                    logger.info('Models cached successfully', {
                        cacheKey,
                        modelCount: Object.keys(models || {}).length,
                        modelNames: Object.keys(models || {}),
                        middleware: 'GraphQLModelInitializer',
                    });
                }
                catch (error) {
                    logger.error('Clearing failed initialization from cache', {
                        cacheKey,
                        error: error instanceof Error ? error.message : String(error),
                        middleware: 'GraphQLModelInitializer',
                    });
                    initializationPromises.delete(cacheKey);
                    modelsCache.delete(cacheKey);
                    throw error;
                }
                finally {
                    initializationPromises.delete(cacheKey);
                }
            }
            input.models = models;
        }
        catch (error) {
            logger.error('GraphQL model initialization failed', {
                originalError: error,
                cacheKey,
                middleware: 'GraphQLModelInitializer',
            });
            throwError('GraphQL model initialization failed', {
                originalError: error,
                cacheKey,
                middleware: 'GraphQLModelInitializer',
            });
        }
        return await next();
    };
}
//# sourceMappingURL=GraphQLModelInitializer.js.map