@platypus-stack/platypus-infra-tools/dist/index.js

Tools & utils to manage infrastructure aspects of platypus projects

// src/lib/docker.ts
import shell from "shelljs";
var isDockerRunning = () => {
  const dockerRunning = shell.exec("docker info", { silent: true });
  return !(dockerRunning.code === 0);
};

// src/lib/dockerNetwork.ts
import shell2 from "shelljs";
async function getDockerNetworkGatewayIP(dockerNetwork) {
  return new Promise((resolve) => {
    shell2.exec(
      `docker network inspect --format='{{range .IPAM.Config}}{{.Gateway}}{{end}}' "${dockerNetwork}"`,
      { silent: true },
      function(code, stdout, stderr) {
        if (stderr) {
          throw new Error("docker network inspect error: " + stderr);
        }
        resolve(stdout);
      }
    );
  });
}
async function getDockerNetworkContainers(dockerNetwork) {
  return new Promise((resolve) => {
    shell2.exec(
      `docker network inspect --format '{{range .Containers}}{{.EndpointID}}|{{end}}' "${dockerNetwork}"`,
      { silent: true },
      function(code, stdout, stderr) {
        if (stderr) {
          throw new Error("docker network inspect error: " + stderr);
        }
        resolve(stdout.split("|").slice(0, -1));
      }
    );
  });
}
async function isDockerNetworkExisting(dockerNetwork) {
  return new Promise((resolve) => {
    shell2.exec(
      `docker network ls | grep -w "${dockerNetwork}"`,
      { silent: true },
      function(code, stdout, stderr) {
        if (stderr) {
          throw new Error("docker network inspect error: " + stderr);
        }
        if (!stdout) {
          resolve(false);
        }
        resolve(true);
      }
    );
  });
}

// src/lib/startPlatypusProject.ts
import { existsSync } from "fs";
import { errorLog, getErrorMessage, infoLog } from "@platypus-stack/platypus-app-tools";
import shell3 from "shelljs";

// src/lib/nodeProcess.ts
var getUID = () => {
  if (!process.getuid) {
    throw Error("process.getuid is not defined");
  }
  return process.getuid().toString();
};
var getGID = () => {
  if (!process.getgid) {
    throw Error("process.getgid is not defined");
  }
  return process.getgid().toString();
};

// src/lib/startPlatypusProject.ts
async function startPlatypusProject({
  dockerNetworkName,
  dockerComposePath,
  pull = false,
  projectDirectory,
  additionalArgs
}) {
  console.log("--- Starting platypus project  ---");
  if (pull) {
    infoLog("Pulling images before starting containers.");
  }
  if (!existsSync(dockerComposePath)) {
    errorLog("docker-compose file not found");
    errorLog(`File ${dockerComposePath} not found.`);
    return;
  }
  if (isDockerRunning()) {
    errorLog("Docker not running. Start Docker first");
    return;
  }
  if (!await isDockerNetworkExisting(dockerNetworkName)) {
    infoLog(`Docker network ${dockerNetworkName} not found. Creating new docker network.`);
    try {
      const creatingNewDockerNetwork = shell3.exec(`docker network create ${dockerNetworkName}`);
      if (creatingNewDockerNetwork.code !== 0) {
        throw Error(creatingNewDockerNetwork.stderr);
      }
    } catch (e) {
      errorLog(`Error while creating docker network ${dockerNetworkName}.`);
      errorLog(getErrorMessage(e));
      return;
    }
  }
  try {
    shell3.env["CURRENT_UID"] = `${getUID()}:${getGID()}`;
    shell3.env["MY_UID"] = `${getUID()}`;
    shell3.env["MY_GID"] = `${getGID()}`;
  } catch (e) {
    errorLog(getErrorMessage(e));
  }
  try {
    const gatewayIP = await getDockerNetworkGatewayIP(dockerNetworkName);
    infoLog("exporting gatewayIP as DOCKER_NETWORK_GATEWAY");
    infoLog(gatewayIP);
    shell3.env["DOCKER_NETWORK_GATEWAY"] = String(gatewayIP).trim();
  } catch (e) {
    errorLog(`Error while getting docker network gateway IP && exporting it for shelljs process.`);
    errorLog(getErrorMessage(e));
    return;
  }
  const composeCMD = `docker compose ${projectDirectory ? `--project-directory ${projectDirectory}` : ""} ${additionalArgs ? additionalArgs : ""} -f ${dockerComposePath}`;
  console.log("Docker compose args:");
  console.log(composeCMD);
  try {
    if (pull) {
      const pullCMD = shell3.exec(`${composeCMD} pull`, { silent: true });
      if (pullCMD.code !== 0) {
        throw Error(pullCMD.stderr);
      }
    }
    const creating = shell3.exec(`${composeCMD} up -d`, { silent: true });
    if (creating.code !== 0) {
      throw Error(creating.stderr);
    }
  } catch (e) {
    errorLog(`Error while starting docker containers`);
    errorLog(getErrorMessage(e));
  }
}
var startPlatypusProject_default = startPlatypusProject;

// src/lib/stopPlatypusProject.ts
import { existsSync as existsSync2 } from "fs";
import { errorLog as errorLog2, getErrorMessage as getErrorMessage2, infoLog as infoLog2 } from "@platypus-stack/platypus-app-tools";
import shell4 from "shelljs";
var stopPlatypusProject = async ({
  dockerComposePath,
  dockerNetworkName,
  projectDirectory,
  additionalArgs,
  removeOrphans
}) => {
  if (!existsSync2(dockerComposePath)) {
    errorLog2("docker-compose file not found");
    errorLog2(`File ${dockerComposePath} not found.`);
    return;
  }
  if (!await isDockerNetworkExisting(dockerNetworkName)) {
    errorLog2(`Docker network ${dockerNetworkName} not found.`);
    return;
  }
  try {
    shell4.env["CURRENT_UID"] = `${getUID()}:${getGID()}`;
  } catch (e) {
    errorLog2(getErrorMessage2(e));
  }
  try {
    const gatewayIP = await getDockerNetworkGatewayIP(dockerNetworkName);
    infoLog2("exporting gatewayIP as DOCKER_NETWORK_GATEWAY");
    infoLog2(gatewayIP);
    shell4.env["DOCKER_NETWORK_GATEWAY"] = String(gatewayIP).trim();
  } catch (e) {
    errorLog2(`Error while getting docker network gateway IP && exporting it for shelljs process.`);
    errorLog2(getErrorMessage2(e));
    return;
  }
  const composeCMD = `docker compose ${projectDirectory ? `--project-directory ${projectDirectory}` : ""} ${additionalArgs ? additionalArgs : ""} -f ${dockerComposePath} down ${removeOrphans ? "--remove-orphans" : ""}`;
  console.log("Docker compose args:");
  console.log(composeCMD);
  try {
    infoLog2(`Stopping docker containers`);
    const stopping = shell4.exec(composeCMD);
    if (stopping.code !== 0) {
      throw Error(stopping.stderr);
    }
  } catch (e) {
    errorLog2(`Error while stopping docker containers.`);
    errorLog2(getErrorMessage2(e));
    return;
  }
  try {
    if (await isDockerNetworkExisting(dockerNetworkName)) {
      if ((await getDockerNetworkContainers(dockerNetworkName)).length === 0) {
        infoLog2(`Removing docker network ${dockerNetworkName}`);
        const networkRemoving = shell4.exec(`docker network rm ${dockerNetworkName}`, { silent: true });
        if (networkRemoving.code !== 0) {
          throw Error(networkRemoving.stderr);
        }
        infoLog2(`Docker network ${dockerNetworkName} removed`);
      } else {
        infoLog2(`Docker network ${dockerNetworkName} not empty.`);
      }
    }
  } catch (e) {
    errorLog2(`Error while removing docker network ${dockerNetworkName}.`);
    errorLog2(getErrorMessage2(e));
    return;
  }
};
var stopPlatypusProject_default = stopPlatypusProject;
export {
  getDockerNetworkContainers,
  getDockerNetworkGatewayIP,
  isDockerNetworkExisting,
  isDockerRunning,
  startPlatypusProject_default as startPlatypusProject,
  stopPlatypusProject_default as stopPlatypusProject
};
//# sourceMappingURL=index.js.map