@govuk-pay/cli 0.0.30 → 0.0.32

package/src/commands/local/app_client/app_client.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const fetch_wrapper_1 = require("./fetch_wrapper");
+const pay_local_cluster_js_1 = require("../config/pay_local_cluster.js");
+let SERVICES_CONFIG;
+const appClient = {
+    async createPaymentLink(apiKey) {
+        const paymentLinkData = {
+            pay_api_token: apiKey,
+            name: 'exampleName',
+            price: 100,
+            gateway_account_id: '1',
+            return_url: 'https://test.test/some_reference',
+            service_name: 'aServiceName',
+            type: 'ADHOC',
+            service_name_path: 'aServiceNamePath',
+            product_name_path: node_crypto_1.default.randomBytes(16).toString('hex'),
+            reference_enabled: false
+        };
+        const url = urlFor('products', '/v1/api/products/');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, paymentLinkData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a request payment links did not have a body, or the body was not JSON!');
+            return;
+        }
+        if (!Object.hasOwn(body, '_links')) {
+            console.error('The response to create a payment link did not include an _links property');
+            return;
+        }
+        const typedBody = body;
+        return typedBody._links;
+    },
+    async createService() {
+        const createServiceData = {
+            en: 'My service',
+            cy: 'Welsh name for My service'
+        };
+        const url = urlFor('adminusers', '/v1/api/services');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createServiceData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a service did not have a body, or the body was not JSON!');
+            return;
+        }
+        if (!Object.hasOwn(body, 'external_id')) {
+            console.error('The response to create a service did not include an external_id property');
+            return;
+        }
+        const typedBody = body;
+        return typedBody.external_id;
+    },
+    async createAccountInServiceWithEmailCollectionMode(serviceExternalID, emailCollectionMode) {
+        const account = await appClient.createAccount(serviceExternalID);
+        if (account === undefined) {
+            console.error('Failed to create account');
+            return;
+        }
+        if (!await appClient.setEmailCollectionModeOnAccount(account.gateway_account_id, emailCollectionMode)) {
+            console.error('Failed to set email collection mode on gateway account');
+            return;
+        }
+        if (!await appClient.addGatewayAccountToService(account.gateway_account_id, serviceExternalID)) {
+            console.error('Failed to add the gateway account to the service');
+            return;
+        }
+        return account;
+    },
+    async createAccount(serviceID) {
+        const createAccountData = {
+            payment_provider: 'sandbox',
+            service_name: 'My service',
+            type: 'test',
+            service_id: serviceID
+        };
+        const url = urlFor('connector', '/v1/api/accounts');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createAccountData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create an account did not have a body, or the body was not JSON!');
+            return;
+        }
+        const typedBody = body;
+        return typedBody;
+    },
+    async setEmailCollectionModeOnAccount(accountID, emailCollectionMode) {
+        const patchEmailCollectionModeData = {
+            op: 'replace',
+            path: 'email_collection_mode',
+            value: emailCollectionMode
+        };
+        const url = urlFor('connector', `/v1/api/accounts/${accountID}`);
+        const result = await (0, fetch_wrapper_1.patchRequest)(url, patchEmailCollectionModeData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return false;
+        }
+        return true;
+    },
+    async addGatewayAccountToService(accountID, serviceID) {
+        const patchAddGatewayAccountToServiceData = {
+            op: 'add',
+            path: 'gateway_account_ids',
+            value: [accountID]
+        };
+        const url = urlFor('adminusers', `/v1/api/services/${serviceID}`);
+        const result = await (0, fetch_wrapper_1.patchRequest)(url, patchAddGatewayAccountToServiceData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return false;
+        }
+        return true;
+    },
+    async createToken(gatewayAccountID) {
+        const createTokenData = {
+            account_id: gatewayAccountID,
+            description: 'my token',
+            created_by: 'system generated',
+            token_type: 'CARD'
+        };
+        const url = urlFor('publicauth', '/v1/frontend/auth');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createTokenData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a token did not have a body, or the body was not JSON!');
+            return;
+        }
+        const typedBody = body;
+        return typedBody.token;
+    },
+    async createPayment(apiToken) {
+        const createPaymentData = {
+            amount: 1000,
+            description: 'my payment',
+            reference: 'my payment reference',
+            return_url: new URL('https://www.payments.service.gov.uk')
+        };
+        const url = urlFor('publicapi', '/v1/payments');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createPaymentData, apiToken);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a payment did not have a body, or the body was not JSON!');
+            return;
+        }
+        return body;
+    },
+    async createUser(gatewayAccountIDs, roleName) {
+        const createUserData = {
+            gateway_account_ids: gatewayAccountIDs,
+            email: `${node_crypto_1.default.randomBytes(16).toString('hex')}@example.com`,
+            password: `${node_crypto_1.default.randomBytes(10).toString('hex')}`,
+            telephone_number: '01134960000',
+            role_name: roleName
+        };
+        const url = urlFor('adminusers', '/v1/api/users');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createUserData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a user did not have a body, or the body was not JSON!');
+            return;
+        }
+        const typedAugmentedBody = {
+            ...createUserData,
+            ...body
+        };
+        return typedAugmentedBody;
+    },
+    async isHealthy(serviceName) {
+        const url = urlFor(serviceName, '/healthcheck');
+        const response = await (0, fetch_wrapper_1.getRequest)(url);
+        return response.success;
+    },
+    async isUnhealthy(serviceName) {
+        return !await this.isHealthy(serviceName);
+    },
+    async isProxyHealthy(serviceName) {
+        const proxyUrl = this.externalUrlFor(serviceName, '/healthcheck', true);
+        const response = await (0, fetch_wrapper_1.getRequest)(proxyUrl);
+        return response.success;
+    },
+    externalUrlFor(serviceName, resource, proxy) {
+        if (SERVICES_CONFIG === undefined) {
+            SERVICES_CONFIG = (0, pay_local_cluster_js_1.loadServicesConfig)();
+        }
+        if (!(serviceName in SERVICES_CONFIG)) {
+            throw new Error(`Tried to look up service config for ${serviceName} but it isn't defined in the service_config.yaml file`);
+        }
+        const proxyPort = SERVICES_CONFIG[serviceName].proxy_port;
+        if (proxy && proxyPort !== undefined) {
+            return `https://127.0.0.1:${proxyPort}${resource}`;
+        }
+        return `http://127.0.0.1:${SERVICES_CONFIG[serviceName].port}${resource}`;
+    }
+};
+function urlFor(serviceName, resource) {
+    if (SERVICES_CONFIG === undefined) {
+        SERVICES_CONFIG = (0, pay_local_cluster_js_1.loadServicesConfig)();
+    }
+    if (!(serviceName in SERVICES_CONFIG)) {
+        throw new Error(`Tried to look up service config for ${serviceName} but it isn't defined in the service_config.yaml file`);
+    }
+    return appClient.externalUrlFor(serviceName, resource, false);
+}
+exports.default = appClient;

package/src/commands/local/app_client/fetch_wrapper.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatErrorMessageForFailedRequest = exports.patchRequest = exports.postRequest = exports.getRequest = void 0;
+async function getRequest(url, authToken) {
+    return await makeRequest(url, { headers: defaultHeaders(authToken) });
+}
+exports.getRequest = getRequest;
+async function postRequest(url, body, authToken) {
+    return await makeRequest(url, {
+        method: 'POST',
+        body: JSON.stringify(body),
+        headers: defaultHeaders(authToken)
+    });
+}
+exports.postRequest = postRequest;
+async function patchRequest(url, body, authToken) {
+    return await makeRequest(url, {
+        method: 'PATCH',
+        body: JSON.stringify(body),
+        headers: defaultHeaders(authToken)
+    });
+}
+exports.patchRequest = patchRequest;
+function formatErrorMessageForFailedRequest(unsuccessfulResult) {
+    if (unsuccessfulResult === undefined) {
+        return 'The result was successful';
+    }
+    let errorMessage = '';
+    if (unsuccessfulResult.error !== null && unsuccessfulResult.error !== undefined) {
+        errorMessage = unsuccessfulResult.error.message;
+    }
+    if (unsuccessfulResult.response === undefined) {
+        return `No response was received from the server, the following error was thrown:\n${errorMessage}`;
+    }
+    else {
+        if (unsuccessfulResult.error === undefined) {
+            return 'The server returned a non-ok HTTP response, no other error was thrown\n' +
+                `Response Code: ${unsuccessfulResult.response?.status}\n` +
+                `Response Text: ${unsuccessfulResult.response?.statusText}`;
+        }
+        else {
+            return 'A response was recevied from the server, but an error was also thrown.\n' +
+                `Error: ${errorMessage}` +
+                `Response Code: ${unsuccessfulResult?.response?.status}\n` +
+                `Response Text: ${unsuccessfulResult?.response?.statusText}`;
+        }
+    }
+}
+exports.formatErrorMessageForFailedRequest = formatErrorMessageForFailedRequest;
+/**
+ * The error handling around requests is absymal, so we'll catch all possible errors and return a result with a
+ * concrete type which is easier for clients to understand and deal with, containing the complexity to only this
+ * function
+ */
+async function makeRequest(url, requestOptions) {
+    let response;
+    try {
+        response = await fetch(url, requestOptions);
+        if (!response.ok) {
+            return {
+                success: false,
+                unsuccessfulResult: {
+                    response
+                }
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            unsuccessfulResult: {
+                error
+            }
+        };
+    }
+    try {
+        const rawBody = await response.text();
+        const jsonResponse = response.headers.get('Content-Type') === 'application/json';
+        return {
+            success: true,
+            successfulResult: {
+                response,
+                body: jsonResponse ? await JSON.parse(rawBody) : rawBody
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            unsuccessfulResult: {
+                response,
+                error
+            }
+        };
+    }
+}
+function defaultHeaders(authToken) {
+    const headers = new Headers({
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+    });
+    if (authToken !== undefined) {
+        headers.set('Authorization', `Bearer ${authToken}`);
+    }
+    return headers;
+}

package/src/commands/local/config/default_config_setup.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyDefaultConfigs = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function copyDefaultConfigs(to) {
+    const sourceDir = node_path_1.default.join(__dirname, '..', '..', '..', '..', 'resources', 'pay-local', 'config');
+    node_fs_1.default.cpSync(sourceDir, to, { recursive: true, force: true });
+}
+exports.copyDefaultConfigs = copyDefaultConfigs;

package/src/commands/local/config/last_up_record.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastUp = exports.recordUp = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const LAST_UP_FILENAME = 'last-up-DO-NOT-EDIT.yaml';
+/* Records the last 'up' command docker-compose file by creating a symlink to it in the
+ * rendered templates path
+ */
+function recordUp(renderedTemplatesPath, cluster) {
+    const lastUpRecordPath = node_path_1.default.resolve(node_path_1.default.join(renderedTemplatesPath, LAST_UP_FILENAME));
+    const lastUpActualFilename = `${cluster.name}.yaml`;
+    node_fs_1.default.rmSync(lastUpRecordPath, { force: true });
+    node_fs_1.default.symlinkSync(lastUpActualFilename, lastUpRecordPath);
+}
+exports.recordUp = recordUp;
+/* Gets the path of the most recently used docker-compose file.
+ *
+ * Returns undefined if one can't be found, otherwise returns the full path
+ * to the yaml file which was last generated by the 'up' command
+ */
+function getLastUp(renderedTemplatesPath) {
+    const lastUpRecordPath = node_path_1.default.resolve(node_path_1.default.join(renderedTemplatesPath, LAST_UP_FILENAME));
+    const pathStat = node_fs_1.default.lstatSync(lastUpRecordPath, { throwIfNoEntry: false });
+    if (pathStat === undefined) {
+        return;
+    }
+    if (!pathStat.isSymbolicLink()) {
+        return;
+    }
+    const symlinkTarget = node_fs_1.default.readlinkSync(lastUpRecordPath);
+    if (symlinkTarget === undefined) {
+        return;
+    }
+    if (!symlinkTarget.endsWith('.yaml')) {
+        return;
+    }
+    const lastUpActualPath = node_path_1.default.resolve(node_path_1.default.join(renderedTemplatesPath, symlinkTarget));
+    const lastUpActualPathStat = node_fs_1.default.statSync(lastUpActualPath, { throwIfNoEntry: false });
+    if (lastUpActualPathStat === undefined) {
+        return;
+    }
+    if (lastUpActualPathStat.isFile()) {
+        return lastUpActualPath;
+    }
+}
+exports.getLastUp = getLastUp;

package/src/commands/local/config/pay_local_cluster.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadServicesConfig = exports.loadClusterConfig = exports.PayLocalCluster = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+const md5_js_1 = require("../../../util/md5.js");
+// This is the complete cluster configuration that will be used as the context for template rendering
+class PayLocalCluster {
+    name;
+    payServices;
+    dbServices;
+    reverseProxyServices;
+    egressProxy;
+    javaApps;
+    nodeApps;
+    localJavaApps;
+    localNodeApps;
+    remoteJavaApps;
+    remoteNodeApps;
+    anyJavaApps;
+    anyNodeApps;
+    workspace;
+    requiresLocalStack;
+    requiresRedis;
+    requiresEgressProxy;
+    serviceURLEnvVars;
+    mountLocalNodeApps;
+    noProxyEnvVar;
+    defaultServiceConfigsPath;
+    environmentOverridesPath;
+    constructor(clusterConfig) {
+        this.name = clusterConfig.name;
+        this.workspace = clusterConfig.workspace;
+        this.payServices = clusterConfig.payServices;
+        this.dbServices = clusterConfig.dbServices;
+        this.reverseProxyServices = clusterConfig.reverseProxyServices;
+        this.egressProxy = clusterConfig.egressProxy;
+        this.javaApps = this.payServices.filter((service) => service.serviceType === PayServiceType.Java);
+        this.nodeApps = this.payServices.filter((service) => service.serviceType === PayServiceType.Node);
+        this.remoteJavaApps = this.javaApps.filter((service) => service.localBuild);
+        this.remoteNodeApps = this.nodeApps.filter((service) => service.localBuild);
+        this.localJavaApps = this.javaApps.filter((service) => service.localBuild);
+        this.localNodeApps = this.nodeApps.filter((service) => service.localBuild);
+        this.anyJavaApps = this.javaApps.length >= 0;
+        this.anyNodeApps = this.nodeApps.length >= 0;
+        this.requiresLocalStack = this.payServices.some((service) => service.requiresLocalStack);
+        this.requiresRedis = this.payServices.some((service) => service.usesRedis);
+        this.requiresEgressProxy = this.egressProxy !== undefined;
+        this.mountLocalNodeApps = clusterConfig.mountLocalNodeApps;
+        this.serviceURLEnvVars = [
+            this.javaApps.map((javaService) => envVarForJavaService(javaService)),
+            this.nodeApps.map((nodeService) => envVarForNodeService(nodeService))
+        ].flat();
+        this.noProxyEnvVar = [
+            'localhost',
+            '127.0.0.1',
+            '172.18.0.253',
+            'localstack',
+            'redis',
+            this.payServices.map((service) => service.name),
+            this.dbServices.map((service) => service.name),
+            this.reverseProxyServices.map((service) => service.name),
+            this.egressProxy === undefined ? [] : this.egressProxy.name
+        ].flat().join(',');
+        this.environmentOverridesPath = clusterConfig.environmentOverridesPath;
+        this.defaultServiceConfigsPath = clusterConfig.defaultServiceConfigsPath;
+    }
+}
+exports.PayLocalCluster = PayLocalCluster;
+function envVarForJavaService(service) {
+    return {
+        name: `${service.name.toUpperCase()}_URL`,
+        value: `http://${service.name}:${service.port}`
+    };
+}
+function envVarForNodeService(service) {
+    return {
+        name: `${service.name.toUpperCase()}_URL`,
+        value: `http://localhost:${service.port}`
+    };
+}
+var PayServiceType;
+(function (PayServiceType) {
+    PayServiceType["Java"] = "java";
+    PayServiceType["Node"] = "node";
+})(PayServiceType || (PayServiceType = {}));
+function loadClusterConfig(options, workspace, defaultServiceConfigsPath, environmentOverridesPath) {
+    const servicesConfig = loadServicesConfig();
+    const payServices = [];
+    for (const [, serviceConfig] of Object.entries(servicesConfig)) {
+        if (includeAppInCluster(options.cluster, options, serviceConfig)) {
+            payServices.push(payServiceFromPayServiceConfig(serviceConfig, options, environmentOverridesPath));
+        }
+    }
+    const dbServices = [];
+    for (const payService of payServices) {
+        if (payService.payServiceConfig.db) {
+            dbServices.push(dbServiceFromPayServiceConfig(payService.payServiceConfig));
+        }
+    }
+    const reverseProxyServices = [];
+    if (options.proxy) {
+        for (const payService of payServices) {
+            if (payService.hasProxy) {
+                reverseProxyServices.push(proxyServiceFromPayServiceConfig(payService.payServiceConfig, workspace));
+            }
+        }
+    }
+    const clusterConfig = {
+        name: options.cluster,
+        payServices,
+        dbServices,
+        reverseProxyServices,
+        workspace,
+        mountLocalNodeApps: options.mount_local_node_apps,
+        defaultServiceConfigsPath,
+        environmentOverridesPath
+    };
+    return new PayLocalCluster(clusterConfig);
+}
+exports.loadClusterConfig = loadClusterConfig;
+function loadServicesConfig() {
+    const servicesConfigPath = node_path_1.default.join(__dirname, '..', '..', '..', '..', 'resources', 'pay-local', 'config', 'service_config.yaml');
+    const serviceConfigFileContents = node_fs_1.default.readFileSync(servicesConfigPath, 'utf8');
+    return yaml_1.default.parse(serviceConfigFileContents);
+}
+exports.loadServicesConfig = loadServicesConfig;
+function includeAppInCluster(cluster, options, serviceConfig) {
+    if (cluster === 'all' || cluster === 'nuke' || serviceConfig.clusters.includes(cluster)) {
+        if (options.apps.length === 0 || options.apps.includes(serviceConfig.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function payServiceFromPayServiceConfig(config, upOptions, environmentOverridesPath) {
+    const ports = [config.port];
+    if (config.admin_port !== undefined)
+        ports.push(config.admin_port);
+    const localBuild = upOptions.local.includes(config.name);
+    const sqsQueues = [];
+    if (config.queues !== undefined) {
+        for (const [envVarName, queueName] of Object.entries(config.queues)) {
+            sqsQueues.push({ envVarName, queueName });
+        }
+    }
+    const snsTopics = [];
+    if (config.sns_topics !== undefined) {
+        for (const [envVarName, topicName] of Object.entries(config.sns_topics)) {
+            snsTopics.push({ envVarName, topicName });
+        }
+    }
+    return {
+        name: config.name,
+        containerName: config.name,
+        port: config.port,
+        adminPort: config.admin_port,
+        debugPort: config.debug_port,
+        volumes: new Map(),
+        serviceType: config.type,
+        localBuild,
+        usesRedis: config.uses_redis === undefined ? false : config.uses_redis,
+        sqsQueues,
+        hasSQSQueues: sqsQueues.length > 0,
+        snsTopics,
+        hasSNSTopics: snsTopics.length > 0,
+        hasProxy: config.proxy === undefined ? false : config.proxy,
+        hasDB: config.db,
+        useEgressProxy: config.can_use_egress_proxy === undefined ? false : config.can_use_egress_proxy && upOptions.with_egress_proxy,
+        dependsOn: config.db ? [`${config.name}_db`] : [],
+        expose: [],
+        payServiceConfig: config,
+        imageTag: localBuild ? 'local' : 'latest-master',
+        requiresLocalStack: sqsQueues.length > 0 || snsTopics.length > 0,
+        entrypointOverrideLocal: config.entrypoint_override_local,
+        environmentOverrideFilePath: node_path_1.default.join(environmentOverridesPath, `${config.name}.env`)
+    };
+}
+function dbServiceFromPayServiceConfig(config) {
+    if (config.db_port === undefined) {
+        throw new Error(`The db specification for ${config.name} (which sets db: true) is missing the db_port specification`);
+    }
+    return {
+        name: `${config.name}_db`,
+        containerName: `${config.name}_db`,
+        dependsOn: [],
+        port: config.db_port,
+        expose: [],
+        volumes: new Map()
+    };
+}
+function proxyServiceFromPayServiceConfig(config, workspace) {
+    if (config.proxy_port === undefined) {
+        throw new Error(`The proxy specification for ${config.name} (which sets proxy: true) is missing the proxy_port specification`);
+    }
+    // TODO: Deal with naxsi rules file and md5s
+    const naxsiSourcePath = naxsiConfigPathForPayServiceConfig(config, workspace);
+    return {
+        name: `${config.name}-proxy`,
+        containerName: `${config.name}-proxy`,
+        appName: config.name,
+        appPort: config.port,
+        port: config.proxy_port,
+        dependsOn: [],
+        expose: [],
+        volumes: new Map(),
+        naxsiRulesSourceFile: naxsiSourcePath,
+        naxsiRulesSourceFileMD5: (0, md5_js_1.md5File)(naxsiSourcePath)
+    };
+}
+function naxsiConfigPathForPayServiceConfig(service, workspace) {
+    const naxsiSourcePath = node_path_1.default.join(workspace, 'pay-infra', 'provisioning', 'terraform', 'modules', 'pay_microservices_v2', service.name, 'files', `${service.name}.naxsi`);
+    const nasxiSourcePathStat = node_fs_1.default.statSync(naxsiSourcePath, { throwIfNoEntry: false });
+    if (nasxiSourcePathStat === undefined) {
+        throw new Error(`Reverse proxies were requested, but the naxsi config file for '${service.name}' (${naxsiSourcePath}') was not found. Perhaps you need to checkout pay-infra into your workspace directory '${workspace}'?`);
+    }
+    if (!nasxiSourcePathStat.isFile()) {
+        throw new Error(`Reverse proxies were requested, but the naxsi config file for '${service.name}' (${naxsiSourcePath}') is not a regular file. Perhaps you need to checkout pay-infra into your workspace directory '${workspace}'?`);
+    }
+    return naxsiSourcePath;
+}

package/src/commands/local/config/renderer.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDockerCompose = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const handlebars_1 = __importDefault(require("handlebars"));
+/**
+ * Renders the 'if' path if both a and b are true, otherwise renders the 'else' path
+ */
+handlebars_1.default.registerHelper('ifBoth', (a, b, options) => {
+    if (a && b) {
+        return options.fn(this);
+    }
+    else {
+        return options.inverse(this);
+    }
+});
+/**
+ * Renders the 'if' path if the file specified exists, otherwise renders the 'else' path
+ */
+handlebars_1.default.registerHelper('ifFileExists', (filePath, options) => {
+    if (node_fs_1.default.existsSync(filePath)) {
+        return options.fn(this);
+    }
+    else {
+        return options.inverse(this);
+    }
+});
+/**
+ * Renders the handlebars template, writes it into the destination directory and returns the path
+ * to the file
+ */
+function renderDockerCompose(cluster, destinationDirectory) {
+    const tempalteSource = loadTemplate();
+    const template = handlebars_1.default.compile(tempalteSource);
+    const destinationFilePath = `${node_fs_1.default.realpathSync(destinationDirectory)}/${cluster.name}.yaml`;
+    node_fs_1.default.writeFileSync(destinationFilePath, template(cluster), { mode: 0o660 });
+    return destinationFilePath;
+}
+exports.renderDockerCompose = renderDockerCompose;
+function loadTemplate() {
+    return node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, '..', '..', '..', '..', 'resources', 'pay-local', 'templates', 'docker-compose.hbs'), 'utf8');
+}