@energica-city/shared-amplify-utils/dist/middleware/rest/RestMiddlewareChain.js

Shared utilities for AWS Amplify projects

import { MiddlewareChain } from '../middlewareChain';
/**
 * Creates a REST middleware chain for composing middleware functions
 * @param config - Configuration options for the middleware chain
 * @param config.enableDebugLogging - Whether to enable debug logging for middleware execution
 * @param config.onError - Error handler callback for middleware errors
 * @returns Configured REST middleware chain instance
 *
 * @example
 * ```typescript
 * const chain = createRestChain<{ User: UserType }>({
 *   enableDebugLogging: true,
 *   onError: (error, middlewareName) => console.error(`Error in ${middlewareName}:`, error)
 * });
 * ```
 */
export function createRestChain(config = {}) {
    return new MiddlewareChain(config);
}
/**
 * Wraps a REST handler function with a middleware chain for AWS Lambda
 * @param chain - The middleware chain to execute before the handler
 * @param handler - The main handler function to wrap
 * @returns Lambda-compatible function that executes middleware chain then handler
 *
 * @example
 * ```typescript
 * const handler = async (input: RestInputWithModels<MyTypes>) => {
 *   return createSuccessResponse({ message: 'Hello World' });
 * };
 *
 * export const lambdaHandler = wrapRestHandler(chain, handler);
 * ```
 */
export function wrapRestHandler(chain, handler) {
    return async (event, context) => {
        const input = { event, context };
        return await chain.execute(input, handler);
    };
}
/**
 * Retrieves all initialized models from the middleware input
 * @param input - REST input containing initialized models
 * @returns Object containing all available model instances
 * @throws Error if models are not available (ModelInitializer middleware not used)
 *
 * @example
 * ```typescript
 * const models = getModelsFromInput(input);
 * const user = await models.User.create({ input: userData });
 * ```
 */
export function getModelsFromInput(input) {
    if (!input.models) {
        throw new Error('Models not available. Ensure RestModelInitializer middleware is used before this handler.');
    }
    return input.models;
}
/**
 * Retrieves a specific model instance from the middleware input
 * @param input - REST input containing initialized models
 * @param modelName - Name of the model to retrieve
 * @returns The requested model instance
 * @throws Error if models are not available or the specific model is not found
 *
 * @example
 * ```typescript
 * const UserModel = getModelFromInput(input, 'User');
 * const user = await UserModel.create({ input: userData });
 * ```
 */
export function getModelFromInput(input, modelName) {
    const models = getModelsFromInput(input);
    const model = models[modelName];
    if (!model) {
        throw new Error(`Model '${String(modelName)}' not found. Available models: ${Object.keys(models).join(', ')}`);
    }
    return model;
}
//# sourceMappingURL=data:application/json;base64,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