@godspeedsystems/godspeed/lib/utils/dockerUtility.js

Godspeed CLI

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.prepareToStartContainers = exports.getComposeOptions = exports.isDockerRunning = void 0;
const docker_compose_1 = __importDefault(require("docker-compose"));
const child_process_1 = require("child_process");
const chalk_1 = __importDefault(require("chalk"));
const signale_1 = require("./signale");
const isDockerRunning = async () => {
    let isRunning = false;
    signale_1.log.wait(`Checking if ${chalk_1.default.yellow("docker")} is installed and running?`);
    try {
        (0, child_process_1.execSync)("docker version", {
            encoding: "utf8",
            maxBuffer: 50 * 1024 * 1024,
            stdio: ["pipe", "pipe", "ignore"],
        }).toString();
        isRunning = true;
        signale_1.log.success(`${chalk_1.default.yellow("docker")} is up and running.`);
    }
    catch (error) {
        isRunning = false;
        signale_1.log.error(`${chalk_1.default.yellow("docker")} is not running.`);
        throw error;
    }
    return isRunning;
};
exports.isDockerRunning = isDockerRunning;
const getComposeOptions = async () => {
    let composeOptions;
    if (process.platform != "win32") {
        let res;
        try {
            res = (0, child_process_1.execSync)(`docker-compose -v`, {
                stdio: ["pipe", "pipe", "ignore"],
            });
        }
        catch (err) { }
        if (!res) {
            composeOptions = {
                executablePath: "docker",
                log: true,
                composeOptions: ["compose", "-p"],
            };
        }
        else {
            composeOptions = {
                log: true,
                composeOptions: ["-p"],
            };
        }
    }
    else {
        composeOptions = {
            executablePath: "docker",
            log: true,
            composeOptions: ["compose", "-p"],
        };
    }
    return composeOptions;
};
exports.getComposeOptions = getComposeOptions;
const prepareToStartContainers = async (projectName, composeOptions) => {
    signale_1.log.wait(`Stopping [if any] already running resources for project ${chalk_1.default.yellow(projectName)}`);
    const downResponse = await docker_compose_1.default.down({
        ...composeOptions,
        commandOptions: ["--remove-orphans"],
    });
    if (downResponse.err) {
        signale_1.log.success(`No running resources found to stop for project ${chalk_1.default.yellow(projectName)}`);
    }
    else {
        signale_1.log.success(`Successfully stopped all running resources for project ${chalk_1.default.yellow(projectName)}`);
    }
};
exports.prepareToStartContainers = prepareToStartContainers;
const prepareMongoDb = async (godspeedOptions, composeOptions) => {
    const { mongodb } = godspeedOptions;
    if (!mongodb) {
        return;
    }
    signale_1.log.wait(`Setting up MongoDB replica cluster.`);
    const responseUpMany = await docker_compose_1.default.upMany([`mongodb1`, `mongodb2`, `mongodb3`], composeOptions);
    const responseExec = await docker_compose_1.default.exec(`mongodb1`, "bash /scripts/mongodb_rs_init.sh", composeOptions);
    signale_1.log.success(`Successfully setup MongoDB replica cluster.`);
};
// const generatePrismaClients = async (
//   composeOptions: IDockerComposeOptions,
//   projectDirPath: string
// ) => {
//   return new Promise((resolve, reject) => {
//     glob(
//       path.resolve(projectDirPath, "src/datasources/*.prisma"),
//       async (err: Error, matches: string[]) => {
//         if (err) {
//           reject(err);
//         } else {
//           if (matches.length) {
//             log.wait("Generating client for prisma datasources.");
//             try {
//               const responseUpAll: IDockerComposeResult =
//                 await dockerCompose.upAll(composeOptions);
//               const responseExec: IDockerComposeResult =
//                 await dockerCompose.exec(
//                   `node`,
//                   [
//                     "/bin/bash",
//                     "-c",
//                     "for i in src/datasources/*.prisma; do npx --yes prisma generate --schema $i && npx --yes prisma db push --schema $i; done",
//                   ],
//                   composeOptions
//                 );
//             } catch (error) {
//               console.log(error);
//             }
//             log.success(
//               "Successfully generated client for prisma datasources."
//             );
//           }
//           resolve("");
//         }
//       }
//     );
//   });
// };
// export const buildContainers = async (
//   projectName: string,
//   godspeedOptions: PlainObject,
//   composeOptions: IDockerComposeOptions,
//   projectDirPath: string
// ) => {
//   try {
//     log.wait(`Building containers for project ${chalk.yellow(projectName)}`);
//     const response = await dockerCompose.buildAll(composeOptions);
//     log.success(
//       `Successfully build all containers for project ${chalk.yellow(
//         projectName
//       )}`
//     );
//     await prepareMongoDb(godspeedOptions, composeOptions);
//     await generatePrismaClients(composeOptions, projectDirPath);
//     await dockerCompose.stop(composeOptions);
//   } catch (error) {
//     console.log(error);
//   }
// };
//# sourceMappingURL=dockerUtility.js.map