typescript-scaffolder/dist/features/generate-webhook-app.js

 ### Unit Test Coverage: 97.12%

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateWebhookApp = generateWebhookApp;
exports.generateWebhookAppFromFile = generateWebhookAppFromFile;
exports.generateWebhookAppFromPath = generateWebhookAppFromPath;
const file_system_1 = require("../utils/file-system");
const path = __importStar(require("path"));
const ts_morph_1 = require("ts-morph");
const logger_1 = require("../utils/logger");
const object_helpers_1 = require("../utils/object-helpers");
const generate_webhooks_1 = require("./generate-webhooks");
const generate_webhook_routes_1 = require("./generate-webhook-routes");
const client_constructors_1 = require("../utils/client-constructors");
const generate_webhook_app_registry_1 = require("./generate-webhook-app-registry");
async function generateWebhookApp(serviceName, outputDir) {
    const funcName = 'generateWebhookApp';
    logger_1.Logger.debug(funcName, `Generating webhook app for service "${serviceName}" in: ${outputDir}`);
    const pascalName = (0, object_helpers_1.toPascalCase)(serviceName);
    const fileName = `create${pascalName}WebhookApp.ts`;
    const functionName = `create${pascalName}WebhookApp`;
    const project = new ts_morph_1.Project();
    const filePath = path.join(outputDir, fileName);
    const sourceFile = project.createSourceFile(filePath, undefined, { overwrite: true });
    sourceFile.addImportDeclarations([
        { moduleSpecifier: 'express', defaultImport: 'express' },
        { moduleSpecifier: './webhookAppRegistry', namedImports: ['webhookAppRegistry'] }
    ]);
    sourceFile.addFunction({
        name: functionName,
        isExported: true,
        statements: `
const app = express();
app.use(express.json());

const handlers = webhookAppRegistry['${serviceName}']?.handlers || {};

for (const key of Object.keys(handlers)) {
  app.post('/' + key, handlers[key]);
}

return app;
`
    });
    await project.save();
}
async function generateWebhookAppFromFile(configPath, interfacesDir, outputDir) {
    const funcName = 'generateWebhookAppFromFile';
    logger_1.Logger.debug(funcName, 'Starting webhook app generation from single config file...');
    const config = (0, file_system_1.readWebhookConfigFile)(configPath);
    if (!config) {
        logger_1.Logger.warn(funcName, `Skipping invalid config file at: ${configPath}`);
        return;
    }
    await (0, generate_webhooks_1.generateWebhooksFromFile)(configPath, interfacesDir, path.join(outputDir, 'routes'));
    await (0, generate_webhook_routes_1.generateWebhookRoutesFromFile)(configPath, interfacesDir, path.join(outputDir, 'routes'));
    const serviceName = path.basename(interfacesDir);
    await (0, generate_webhook_app_registry_1.generateWebhookAppRegistry)(outputDir);
    await generateWebhookApp(serviceName, outputDir);
}
async function generateWebhookAppFromPath(configDir, interfacesRootDir, outputRootDir) {
    const funcName = 'generateWebhookAppFromPath';
    logger_1.Logger.debug(funcName, 'Starting webhook app generation from config directory...');
    const { configFiles, interfaceNameToDirs } = (0, file_system_1.extractInterfaces)(configDir, interfacesRootDir);
    for (const configPath of configFiles) {
        const config = (0, file_system_1.readWebhookConfigFile)(configPath);
        if (!config) {
            continue;
        }
        const requiredSchemas = (0, client_constructors_1.collectRequiredSchemas)(config.webhooks);
        const foundDir = (0, client_constructors_1.findDirectoryContainingAllSchemas)(requiredSchemas, interfaceNameToDirs, configPath, funcName);
        if (!foundDir) {
            logger_1.Logger.warn(funcName, `Could not find a directory containing all schemas for config: ${configPath}`);
            continue;
        }
        // Compute relative path of foundDir to interfacesRootDir to preserve structure in outputRootDir
        const relativeInterfaceDir = path.relative(interfacesRootDir, foundDir);
        const outputDir = path.join(outputRootDir, relativeInterfaceDir);
        await (0, file_system_1.ensureDir)(outputDir);
        await generateWebhookAppFromFile(configPath, foundDir, outputDir);
    }
    logger_1.Logger.info(funcName, 'Webhook app generation completed.');
}