underpost 2.8.44 → 2.8.46

package/manifests/mongodb/backup-access.yaml

@@ -0,0 +1,16 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: backup-access
+spec:
+  containers:
+    - name: busybox
+      image: busybox
+      command: ['sh', '-c', 'sleep 3600']
+      volumeMounts:
+        - name: backup-storage
+          mountPath: /backup
+  volumes:
+    - name: backup-storage
+      persistentVolumeClaim:
+        claimName: backup-pvc

package/manifests/mongodb/backup-cronjob.yaml

@@ -0,0 +1,40 @@
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: mongodb-backup
+spec:
+  schedule: '*/5 * * * *' # Runs backup every five minutes
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+            - name: mongodump
+              image: docker.io/library/mongo:latest
+              command:
+                - sh
+                - -c
+                - |
+                  # Perform backup
+                  mongodump -u $MONGO_INITDB_ROOT_USERNAME -p $MONGO_INITDB_ROOT_PASSWORD --host=mongodb-service --port=27017 --out=/backup/$(date +\%Y-\%m-\%dT\%H-\%M-\%S)
+                  # Remove backups older than 7 days
+                  find /backup -type d -mtime +7 -exec rm -rf {} +
+              volumeMounts:
+                - name: backup-storage
+                  mountPath: /backup
+              env:
+                - name: MONGO_INITDB_ROOT_USERNAME
+                  valueFrom:
+                    secretKeyRef:
+                      name: mongodb-secret
+                      key: username
+                - name: MONGO_INITDB_ROOT_PASSWORD
+                  valueFrom:
+                    secretKeyRef:
+                      name: mongodb-secret
+                      key: password
+          restartPolicy: Never
+          volumes:
+            - name: backup-storage
+              persistentVolumeClaim:
+                claimName: backup-pvc

package/manifests/mongodb/backup-pv-pvc.yaml

@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: PersistentVolume
+metadata:
+  name: backup-pv
+spec:
+  capacity:
+    storage: 5Gi
+  accessModes:
+    - ReadWriteOnce
+  hostPath:
+    path: /mnt/backup
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: backup-pvc
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 5Gi

package/manifests/mongodb/configmap.yaml

@@ -0,0 +1,26 @@
+# origin conf: /etc/mongod.conf
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: mongodb-config-file
+  namespace: default
+data:
+  mongod.conf: |
+    storage:
+      dbPath: /data/db
+    systemLog:
+      destination: file
+      logAppend: true
+      path: /var/log/mongodb/mongod.log
+    replication:
+      replSetName: rs0
+    net:
+      bindIp: 127.0.0.1
+      port: 27017
+    processManagement:
+      fork: true
+    setParameter:
+      enableLocalhostAuthBypass: false
+    security:
+      authorization: enabled
+      keyFile: /etc/mongodb-keyfile

package/manifests/mongodb/headless-service.yaml

@@ -0,0 +1,10 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: mongodb-service
+spec:
+  clusterIP: None
+  selector:
+    app: mongodb
+  ports:
+    - port: 27017

package/manifests/mongodb/kustomization.yaml

@@ -0,0 +1,11 @@
+---
+# kubectl apply -k core/.
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+resources:
+  - pv-pvc.yaml
+  - headless-service.yaml
+  - statefulset.yaml
+  - backup-pv-pvc.yaml
+  - backup-cronjob.yaml
+  - backup-access.yaml

package/manifests/mongodb/pv-pvc.yaml

@@ -0,0 +1,23 @@
+apiVersion: v1
+kind: PersistentVolume
+metadata:
+  name: mongodb-pv
+spec:
+  capacity:
+    storage: 5Gi
+  accessModes:
+    - ReadWriteOnce
+  hostPath:
+    path: /data/mongodb
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: mongodb-pvc
+spec:
+  storageClassName: ''
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 5Gi

package/manifests/mongodb/statefulset.yaml

@@ -0,0 +1,125 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: mongodb # Specifies the name of the statefulset
+spec:
+  serviceName: 'mongodb-service' # Specifies the service to use
+  replicas: 2
+  selector:
+    matchLabels:
+      app: mongodb
+  template:
+    metadata:
+      labels:
+        app: mongodb
+    spec:
+      containers:
+        - name: mongodb
+          image: docker.io/library/mongo:latest
+          command:
+            - mongod
+            - '--replSet'
+            - 'rs0'
+            # - '--config'
+            # - '-f'
+            # - '/etc/mongod.conf'
+            # - '--auth'
+            # - '--clusterAuthMode'
+            # - 'keyFile'
+            # - '--keyFile'
+            # - '/etc/mongodb-keyfile'
+            # - '--interleave'
+            # - 'all'
+            # - '--wiredTigerCacheSizeGB'
+            # - '0.25'
+            # - '--setParameter'
+            # - 'authenticationMechanisms=SCRAM-SHA-1'
+            # - '--fork'
+            - '--logpath'
+            - '/var/log/mongodb/mongod.log'
+            - '--bind_ip_all'
+          # command: ['sh', '-c']
+          # args:
+          #   - |
+          #     mongod --replSet rs0 --bind_ip_all &
+          #     sleep 1000
+          #     if mongosh --host mongodb-0.mongodb-service:27017 --eval "rs.status()" | grep -q "not yet initialized"; then
+          #       mongosh --host mongodb-0.mongodb-service:27017 <<EOF
+          #       use admin;
+          #       rs.initiate({
+          #         _id: "rs0",
+          #         members: [
+          #           { _id: 0, host: "mongodb-0.mongodb-service:27017", priority: 1 },
+          #           { _id: 1, host: "mongodb-1.mongodb-service:27017", priority: 1 }
+          #         ]
+          #       });
+          #       db.getSiblingDB("admin").createUser({
+          #         user: process.env.MONGO_INITDB_ROOT_USERNAME,
+          #         pwd: process.env.MONGO_INITDB_ROOT_PASSWORD,
+          #         roles: [{ role: "userAdminAnyDatabase", db: "admin" }]
+          #       });
+          #       use default;
+          #       db.createUser(
+          #         {
+          #           user: process.env.MONGO_INITDB_ROOT_USERNAME,
+          #           pwd: process.env.MONGO_INITDB_ROOT_PASSWORD,
+          #           roles: [
+          #             { role: "read", db: "test" },
+          #             { role: "readWrite", db: "default" }
+          #           ]
+          #         }
+          #       );
+          #       EOF
+          #     fi
+          #     wait
+          ports:
+            - containerPort: 27017
+          volumeMounts:
+            - name: mongodb-storage
+              mountPath: /data/db
+            - name: keyfile
+              mountPath: /etc/mongodb-keyfile
+              readOnly: true
+            # - name: mongodb-configuration-file
+            #   mountPath: /etc/mongod.conf
+            #   subPath: mongod.conf
+            #   readOnly: true
+            # - name: mongodb-config
+            #   mountPath: /config
+          env:
+            - name: MONGO_INITDB_ROOT_USERNAME
+              valueFrom:
+                secretKeyRef:
+                  name: mongodb-secret
+                  key: username
+            - name: MONGO_INITDB_ROOT_PASSWORD
+              valueFrom:
+                secretKeyRef:
+                  name: mongodb-secret
+                  key: password
+          resources:
+            requests:
+              cpu: '100m'
+              memory: '256Mi'
+            limits:
+              cpu: '500m'
+              memory: '512Mi'
+      volumes:
+        - name: keyfile
+          secret:
+            secretName: mongodb-keyfile
+            defaultMode: 0400
+        # - name: mongodb-configuration-file
+        #   configMap:
+        #     name: mongodb-config-file
+        # - name: mongodb-config
+        #   configMap:
+        #     name: mongodb-config
+  volumeClaimTemplates:
+    - metadata:
+        name: mongodb-storage
+      spec:
+        accessModes: ['ReadWriteOnce']
+        resources:
+          requests:
+            storage: 5Gi

package/manifests/valkey/kustomization.yaml

@@ -3,5 +3,5 @@
 apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
 resources:
-  - underpost-engine-valkey-service.yaml
-  - underpost-engine-valkey-statefulset.yaml
+  - service.yaml
+  - statefulset.yaml

package/manifests/valkey/service.yaml

@@ -0,0 +1,17 @@
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: service-valkey
+  namespace: default
+spec:
+  ports:
+    - port: 6379
+      targetPort: 6379
+  selector:
+    app: service-valkey
+  ipFamilyPolicy: PreferDualStack
+  ipFamilies:
+    - IPv4
+    # - IPv6
+  type: ClusterIP

package/manifests/valkey/statefulset.yaml

@@ -0,0 +1,39 @@
+---
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: service-valkey
+  namespace: default
+spec:
+  serviceName: service-valkey
+  replicas: 1
+  selector:
+    matchLabels:
+      app: service-valkey
+  template:
+    metadata:
+      labels:
+        app: service-valkey
+    spec:
+      containers:
+        - name: service-valkey
+          image: docker.io/valkey/valkey:latest
+          env:
+            - name: TZ
+              value: Europe/Zurich
+          ports:
+            - containerPort: 6379
+          startupProbe:
+            tcpSocket:
+              port: 6379
+            failureThreshold: 30
+            periodSeconds: 5
+            timeoutSeconds: 5
+          livenessProbe:
+            tcpSocket:
+              port: 6379
+            failureThreshold: 2
+            periodSeconds: 30
+            timeoutSeconds: 5
+      restartPolicy: Always
+      automountServiceAccountToken: false

package/package.json

@@ -2,20 +2,27 @@
     "type": "module",
     "main": "src/index.js",
     "name": "underpost",
-    "version": "2.8.44",
+    "version": "2.8.46",
     "description": "pwa api rest template",
     "scripts": {
         "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",
-        "build": "node bin/deploy build-full-client",
+        "test": "env-cmd -f .env.test c8 mocha",
+        "pm2": "env-cmd -f .env.production pm2 start src/server.js --node-args=\"--max-old-space-size=8192\" --name engine",
         "dev": "env-cmd -f .env.development node src/client.dev default",
+        "dev-img": "env-cmd -f .env.development node src/server",
         "dev-api": "env-cmd -f .env.development nodemon --watch src --ignore src/client src/api",
+        "dev-client": "env-cmd -f .env.development node src/client.dev",
+        "proxy": "node src/proxy proxy",
         "docs": "jsdoc -c jsdoc.json",
         "install-global": "npm install -g pm2 && npm install -g jsdoc && npm install -g prettier && npm install -g env-cmd && npm install -g yarn && npm install -g auto-changelog",
         "install-test": "npm install -g mocha && npm install -g c8 && npm install -g nyc && npm install -g coveralls",
+        "install-underpost": "cp -a $(npm root -g)/underpost/node_modules ./node_modules && npm install --only=dev --ignore-scripts",
         "install": "npm run install-global && npm run install-test",
         "docker:start": "docker-compose up",
         "prettier": "prettier --write .",
-        "test": "env-cmd -f .env.test c8 mocha"
+        "fix": "npm audit fix --force && npm audit",
+        "changelog": "auto-changelog",
+        "build": "node bin/deploy build-full-client"
     },
     "bin": {
         "underpost": "bin/index.js"
@@ -25,6 +32,14 @@
         "url": "git+https://github.com/underpostnet/pwa-microservices-template.git"
     },
     "keywords": [
+        "pwa",
+        "microservices",
+        "template",
+        "builder",
+        "pwa",
+        "microservices",
+        "template",
+        "builder",
         "engine",
         "server",
         "proxy",
@@ -99,12 +114,17 @@
         "uglify-js": "^3.17.4",
         "validator": "^13.11.0",
         "vanilla-jsoneditor": "^2.3.2",
-        "winston": "^3.11.0"
+        "winston": "^3.11.0",
+        "clean-jsdoc-theme": "^4.3.0",
+        "easy-json-schema": "^0.0.2-beta",
+        "mocha": "^10.8.2",
+        "plantuml": "^0.0.2",
+        "swagger-autogen": "^2.23.7"
     },
     "devDependencies": {
         "clean-jsdoc-theme": "^4.3.0",
         "easy-json-schema": "^0.0.2-beta",
-        "mocha": "^10.4.0",
+        "mocha": "^10.8.2",
         "plantuml": "^0.0.2",
         "swagger-autogen": "^2.23.7"
     },

package/src/cli/cluster.js

@@ -0,0 +1,154 @@
+import { timer } from '../client/components/core/CommonJs.js';
+import { cliSpinner } from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostCluster {
+  static API = {
+    async init(options = { valkey: false, mariadb: false, valkey: false, full: false, info: false, nsUse: '' }) {
+      if (options.nsUse) {
+        shellExec(`kubectl config set-context --current --namespace=${options.nsUse}`);
+        return;
+      }
+      if (options.info) {
+        shellExec(`kubectl config get-contexts`); // config env persisente for manage multiple clusters
+        shellExec(`kubectl config get-clusters`);
+        shellExec(`kubectl get nodes -o wide`); // set of nodes of a cluster
+        shellExec(`kubectl config view | grep namespace`);
+        shellExec(`kubectl get ns -o wide`); // A namespace can have pods of different nodes
+        shellExec(`kubectl get pvc --all-namespaces -o wide`); // PersistentVolumeClaim -> request storage service
+        shellExec(`kubectl get pv --all-namespaces -o wide`); // PersistentVolume -> real storage
+        shellExec(`kubectl get cronjob --all-namespaces -o wide`);
+        shellExec(`kubectl get svc --all-namespaces -o wide`); // proxy dns gate way -> deployments, statefulsets, pods
+        shellExec(`kubectl get statefulsets --all-namespaces -o wide`); // set pods with data/volume persistence
+        shellExec(`kubectl get deployments --all-namespaces -o wide`); // set pods
+        shellExec(`kubectl get configmap --all-namespaces -o wide`);
+        shellExec(`kubectl get pods --all-namespaces -o wide`);
+        shellExec(
+          `kubectl get pod --all-namespaces -o="custom-columns=NAME:.metadata.name,INIT-CONTAINERS:.spec.initContainers[*].name,CONTAINERS:.spec.containers[*].name"`,
+        );
+        shellExec(
+          `kubectl get pods --all-namespaces -o=jsonpath='{range .items[*]}{"\\n"}{.metadata.name}{":\\t"}{range .spec.containers[*]}{.image}{", "}{end}{end}'`,
+        );
+        console.log();
+        logger.info('contour -------------------------------------------------');
+        for (const _k of ['Cluster', 'HTTPProxy', 'ClusterIssuer', 'Certificate']) {
+          shellExec(`kubectl get ${_k} --all-namespaces -o wide`);
+        }
+        logger.info('----------------------------------------------------------------');
+        shellExec(`kubectl get secrets --all-namespaces -o wide`);
+        shellExec(`docker secret ls`);
+        return;
+      }
+      const testClusterInit = shellExec(`kubectl get pods --all-namespaces -o wide`, {
+        disableLogging: true,
+        silent: true,
+        stdout: true,
+      });
+      if (!(testClusterInit.match('kube-system') && testClusterInit.match('kube-proxy'))) {
+        shellExec(`containerd config default > /etc/containerd/config.toml`);
+        shellExec(`sed -i -e "s/SystemdCgroup = false/SystemdCgroup = true/g" /etc/containerd/config.toml`);
+        // shellExec(`cp /etc/kubernetes/admin.conf ~/.kube/config`);
+        shellExec(`sudo systemctl restart kubelet`);
+        shellExec(`sudo service docker restart`);
+        shellExec(`cd ./manifests && kind create cluster --config kind-config.yaml`);
+        shellExec(`sudo chown $(id -u):$(id -g) $HOME/.kube/config**`);
+      } else logger.warn('Cluster already initialized');
+
+      if (options.full || options.valkey) {
+        shellExec(`kubectl delete statefulset service-valkey`);
+        shellExec(`kubectl apply -k ./manifests/valkey`);
+      }
+      if (options.full || options.mariadb) {
+        shellExec(
+          `sudo kubectl create secret generic mariadb-secret --from-file=username=/home/dd/engine/engine-private/mariadb-username --from-file=password=/home/dd/engine/engine-private/mariadb-password`,
+        );
+        shellExec(
+          `sudo kubectl create secret generic github-secret --from-literal=GITHUB_TOKEN=${process.env.GITHUB_TOKEN}`,
+        );
+        shellExec(`kubectl delete statefulset mariadb-statefulset`);
+        shellExec(`kubectl apply -k ./manifests/mariadb`);
+      }
+      if (options.full || options.mongodb) {
+        shellExec(
+          `sudo kubectl create secret generic mongodb-keyfile --from-file=/home/dd/engine/engine-private/mongodb-keyfile`,
+        );
+        shellExec(
+          `sudo kubectl create secret generic mongodb-secret --from-file=username=/home/dd/engine/engine-private/mongodb-username --from-file=password=/home/dd/engine/engine-private/mongodb-password`,
+        );
+        shellExec(`kubectl delete statefulset mongodb`);
+        shellExec(`kubectl apply -k ./manifests/mongodb`);
+
+        await new Promise(async (resolve) => {
+          cliSpinner(3000, `[cluster.js] `, ` Load mongodb instance`, 'yellow', 'material');
+          await timer(3000);
+
+          const monitor = async () => {
+            cliSpinner(1000, `[cluster.js] `, ` Load mongodb instance`, 'yellow', 'material');
+            await timer(1000);
+            if (
+              shellExec(`kubectl get pods --all-namespaces -o wide`, {
+                silent: true,
+                stdout: true,
+                disableLog: true,
+              }).match(`mongodb-1                                    1/1     Running`)
+            )
+              return resolve();
+            return monitor();
+          };
+          await monitor();
+        });
+
+        const mongoConfig = {
+          _id: 'rs0',
+          members: [
+            { _id: 0, host: 'mongodb-0.mongodb-service:27017', priority: 1 },
+            { _id: 1, host: 'mongodb-1.mongodb-service:27017', priority: 1 },
+          ],
+        };
+
+        shellExec(
+          `sudo kubectl exec -i mongodb-0 -- mongosh --quiet --json=relaxed \
+          --eval 'use admin' \
+          --eval 'rs.initiate(${JSON.stringify(mongoConfig)})' \
+          --eval 'rs.status()'`,
+        );
+      }
+
+      if (options.full || options.contour)
+        shellExec(`kubectl apply -f https://projectcontour.io/quickstart/contour.yaml`);
+    },
+    reset() {
+      shellExec(`kind get clusters | xargs -t -n1 kind delete cluster --name`);
+      shellExec(`sudo kubeadm reset -f`);
+      shellExec('sudo rm -f /etc/cni/net.d/10-flannel.conflist');
+      shellExec('sudo iptables -F && sudo iptables -t nat -F && sudo iptables -t mangle -F && sudo iptables -X');
+      shellExec('sudo rm -f $HOME/.kube/config');
+      shellExec('sudo rm -rf /root/.local/share/Trash/files/*');
+      shellExec('sudo docker system prune -a -f');
+      shellExec('sudo service docker stop');
+      shellExec(`sudo rm -rf /var/lib/containers/storage/*`);
+      shellExec(`sudo rm -rf /var/lib/docker/volumes/*`);
+      shellExec(`sudo rm -rf /var/lib/docker~/*`);
+      shellExec(`sudo rm -rf /home/containers/storage/*`);
+      shellExec(`sudo rm -rf /home/docker/*`);
+      shellExec('sudo mv /var/lib/docker /var/lib/docker~');
+      shellExec('sudo mkdir /home/docker');
+      shellExec('sudo chmod 0711 /home/docker');
+      shellExec('sudo ln -s /home/docker /var/lib/docker');
+      shellExec(`sudo podman system prune -a -f`);
+      shellExec(`sudo podman system prune --all --volumes --force`);
+      shellExec(`sudo podman system prune --external --force`);
+      shellExec(`sudo podman system prune --all --volumes --force`);
+      shellExec(`sudo mkdir -p /home/containers/storage`);
+      shellExec('sudo chmod 0711 /home/containers/storage');
+      shellExec(
+        `sudo sed -i -e "s@/var/lib/containers/storage@/home/containers/storage@g" /etc/containers/storage.conf`,
+      );
+      shellExec(`sudo podman system reset -f`);
+    },
+  };
+}
+export default UnderpostCluster;

package/src/cli/db.js

@@ -0,0 +1,98 @@
+import { mergeFile } from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostDB {
+  static API = {
+    async import(options = { import: 'default' }) {
+      for (const _deployId of options.import.split(',')) {
+        const deployId = _deployId.trim();
+        if (!deployId) continue;
+        const dbs = {};
+        const repoName = `engine-${deployId.split('dd-')[1]}-cron-backups`;
+
+        const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
+        for (const host of Object.keys(confServer)) {
+          for (const path of Object.keys(confServer[host])) {
+            const { db } = confServer[host][path];
+            if (db) {
+              const { provider, name, user, password } = db;
+              if (!dbs[provider]) dbs[provider] = {};
+
+              if (!(name in dbs[provider]))
+                dbs[provider][name] = { user, password, hostFolder: host + path.replaceAll('/', '-') };
+            }
+          }
+        }
+
+        if (!fs.existsSync(`../${repoName}`)) {
+          shellExec(`cd .. && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}`);
+        } else {
+          shellExec(`cd ../${repoName} && underpost pull . ${process.env.GITHUB_USERNAME}/${repoName}`);
+        }
+
+        for (const provider of Object.keys(dbs)) {
+          for (const dbName of Object.keys(dbs[provider])) {
+            const { hostFolder, user, password } = dbs[provider][dbName];
+            if (hostFolder) {
+              logger.info('import', { hostFolder, provider, dbName });
+
+              const backUpPath = `../${repoName}/${hostFolder}`;
+              const times = await fs.readdir(backUpPath);
+              const currentBackupTimestamp = Math.max(...times.map((t) => parseInt(t)));
+              dbs[provider][dbName].currentBackupTimestamp = currentBackupTimestamp;
+
+              const _fromPartsParts = `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${dbName}-parths.json`;
+              const _toSqlPath = `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${dbName}.sql`;
+              const _toBsonPath = `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${dbName}`;
+
+              if (fs.existsSync(_fromPartsParts) && !fs.existsSync(_toSqlPath)) {
+                const names = JSON.parse(fs.readFileSync(_fromPartsParts, 'utf8')).map((_path) => {
+                  return `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${_path.split('/').pop()}`;
+                });
+                logger.info('merge Back Up paths', {
+                  _fromPartsParts,
+                  _toSqlPath,
+                  names,
+                });
+                await mergeFile(names, _toSqlPath);
+              }
+
+              switch (provider) {
+                case 'mariadb': {
+                  const podName = `mariadb-statefulset-0`;
+                  const nameSpace = 'default';
+                  const serviceName = 'mariadb';
+                  shellExec(`sudo kubectl cp ${_toSqlPath} ${nameSpace}/${podName}:/${dbName}.sql`);
+                  const cmd = `mariadb -u ${user} -p${password} ${dbName} < /${dbName}.sql`;
+                  shellExec(
+                    `kubectl exec -i ${podName} -- ${serviceName} -p${password} -e 'CREATE DATABASE ${dbName};'`,
+                  );
+                  shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                  break;
+                }
+
+                case 'mongoose': {
+                  const podName = `mongodb-0`;
+                  const nameSpace = 'default';
+                  shellExec(`sudo kubectl cp ${_toBsonPath} ${nameSpace}/${podName}:/${dbName}`);
+                  const cmd = `mongorestore -d ${dbName} /${dbName}`;
+                  shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                  break;
+                }
+
+                default:
+                  break;
+              }
+            }
+          }
+        }
+      }
+    },
+  };
+}
+
+export default UnderpostDB;