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

Tools & utils to manage infrastructure aspects of platypus projects

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  getDockerNetworkContainers: () => getDockerNetworkContainers,
  getDockerNetworkGatewayIP: () => getDockerNetworkGatewayIP,
  isDockerNetworkExisting: () => isDockerNetworkExisting,
  isDockerRunning: () => isDockerRunning,
  startPlatypusProject: () => startPlatypusProject_default,
  stopPlatypusProject: () => stopPlatypusProject_default
});
module.exports = __toCommonJS(src_exports);

// src/lib/docker.ts
var import_shelljs = __toESM(require("shelljs"), 1);
var isDockerRunning = () => {
  const dockerRunning = import_shelljs.default.exec("docker info", { silent: true });
  return !(dockerRunning.code === 0);
};

// src/lib/dockerNetwork.ts
var import_shelljs2 = __toESM(require("shelljs"), 1);
async function getDockerNetworkGatewayIP(dockerNetwork) {
  return new Promise((resolve) => {
    import_shelljs2.default.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) => {
    import_shelljs2.default.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) => {
    import_shelljs2.default.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
var import_fs = require("fs");
var import_platypus_app_tools = require("@platypus-stack/platypus-app-tools");
var import_shelljs3 = __toESM(require("shelljs"), 1);

// 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) {
    (0, import_platypus_app_tools.infoLog)("Pulling images before starting containers.");
  }
  if (!(0, import_fs.existsSync)(dockerComposePath)) {
    (0, import_platypus_app_tools.errorLog)("docker-compose file not found");
    (0, import_platypus_app_tools.errorLog)(`File ${dockerComposePath} not found.`);
    return;
  }
  if (isDockerRunning()) {
    (0, import_platypus_app_tools.errorLog)("Docker not running. Start Docker first");
    return;
  }
  if (!await isDockerNetworkExisting(dockerNetworkName)) {
    (0, import_platypus_app_tools.infoLog)(`Docker network ${dockerNetworkName} not found. Creating new docker network.`);
    try {
      const creatingNewDockerNetwork = import_shelljs3.default.exec(`docker network create ${dockerNetworkName}`);
      if (creatingNewDockerNetwork.code !== 0) {
        throw Error(creatingNewDockerNetwork.stderr);
      }
    } catch (e) {
      (0, import_platypus_app_tools.errorLog)(`Error while creating docker network ${dockerNetworkName}.`);
      (0, import_platypus_app_tools.errorLog)((0, import_platypus_app_tools.getErrorMessage)(e));
      return;
    }
  }
  try {
    import_shelljs3.default.env["CURRENT_UID"] = `${getUID()}:${getGID()}`;
    import_shelljs3.default.env["MY_UID"] = `${getUID()}`;
    import_shelljs3.default.env["MY_GID"] = `${getGID()}`;
  } catch (e) {
    (0, import_platypus_app_tools.errorLog)((0, import_platypus_app_tools.getErrorMessage)(e));
  }
  try {
    const gatewayIP = await getDockerNetworkGatewayIP(dockerNetworkName);
    (0, import_platypus_app_tools.infoLog)("exporting gatewayIP as DOCKER_NETWORK_GATEWAY");
    (0, import_platypus_app_tools.infoLog)(gatewayIP);
    import_shelljs3.default.env["DOCKER_NETWORK_GATEWAY"] = String(gatewayIP).trim();
  } catch (e) {
    (0, import_platypus_app_tools.errorLog)(`Error while getting docker network gateway IP && exporting it for shelljs process.`);
    (0, import_platypus_app_tools.errorLog)((0, import_platypus_app_tools.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 = import_shelljs3.default.exec(`${composeCMD} pull`, { silent: true });
      if (pullCMD.code !== 0) {
        throw Error(pullCMD.stderr);
      }
    }
    const creating = import_shelljs3.default.exec(`${composeCMD} up -d`, { silent: true });
    if (creating.code !== 0) {
      throw Error(creating.stderr);
    }
  } catch (e) {
    (0, import_platypus_app_tools.errorLog)(`Error while starting docker containers`);
    (0, import_platypus_app_tools.errorLog)((0, import_platypus_app_tools.getErrorMessage)(e));
  }
}
var startPlatypusProject_default = startPlatypusProject;

// src/lib/stopPlatypusProject.ts
var import_fs2 = require("fs");
var import_platypus_app_tools2 = require("@platypus-stack/platypus-app-tools");
var import_shelljs4 = __toESM(require("shelljs"), 1);
var stopPlatypusProject = async ({
  dockerComposePath,
  dockerNetworkName,
  projectDirectory,
  additionalArgs,
  removeOrphans
}) => {
  if (!(0, import_fs2.existsSync)(dockerComposePath)) {
    (0, import_platypus_app_tools2.errorLog)("docker-compose file not found");
    (0, import_platypus_app_tools2.errorLog)(`File ${dockerComposePath} not found.`);
    return;
  }
  if (!await isDockerNetworkExisting(dockerNetworkName)) {
    (0, import_platypus_app_tools2.errorLog)(`Docker network ${dockerNetworkName} not found.`);
    return;
  }
  try {
    import_shelljs4.default.env["CURRENT_UID"] = `${getUID()}:${getGID()}`;
  } catch (e) {
    (0, import_platypus_app_tools2.errorLog)((0, import_platypus_app_tools2.getErrorMessage)(e));
  }
  try {
    const gatewayIP = await getDockerNetworkGatewayIP(dockerNetworkName);
    (0, import_platypus_app_tools2.infoLog)("exporting gatewayIP as DOCKER_NETWORK_GATEWAY");
    (0, import_platypus_app_tools2.infoLog)(gatewayIP);
    import_shelljs4.default.env["DOCKER_NETWORK_GATEWAY"] = String(gatewayIP).trim();
  } catch (e) {
    (0, import_platypus_app_tools2.errorLog)(`Error while getting docker network gateway IP && exporting it for shelljs process.`);
    (0, import_platypus_app_tools2.errorLog)((0, import_platypus_app_tools2.getErrorMessage)(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 {
    (0, import_platypus_app_tools2.infoLog)(`Stopping docker containers`);
    const stopping = import_shelljs4.default.exec(composeCMD);
    if (stopping.code !== 0) {
      throw Error(stopping.stderr);
    }
  } catch (e) {
    (0, import_platypus_app_tools2.errorLog)(`Error while stopping docker containers.`);
    (0, import_platypus_app_tools2.errorLog)((0, import_platypus_app_tools2.getErrorMessage)(e));
    return;
  }
  try {
    if (await isDockerNetworkExisting(dockerNetworkName)) {
      if ((await getDockerNetworkContainers(dockerNetworkName)).length === 0) {
        (0, import_platypus_app_tools2.infoLog)(`Removing docker network ${dockerNetworkName}`);
        const networkRemoving = import_shelljs4.default.exec(`docker network rm ${dockerNetworkName}`, { silent: true });
        if (networkRemoving.code !== 0) {
          throw Error(networkRemoving.stderr);
        }
        (0, import_platypus_app_tools2.infoLog)(`Docker network ${dockerNetworkName} removed`);
      } else {
        (0, import_platypus_app_tools2.infoLog)(`Docker network ${dockerNetworkName} not empty.`);
      }
    }
  } catch (e) {
    (0, import_platypus_app_tools2.errorLog)(`Error while removing docker network ${dockerNetworkName}.`);
    (0, import_platypus_app_tools2.errorLog)((0, import_platypus_app_tools2.getErrorMessage)(e));
    return;
  }
};
var stopPlatypusProject_default = stopPlatypusProject;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  getDockerNetworkContainers,
  getDockerNetworkGatewayIP,
  isDockerNetworkExisting,
  isDockerRunning,
  startPlatypusProject,
  stopPlatypusProject
});
//# sourceMappingURL=index.cjs.map