@paralect/hive 0.0.2 → 0.0.4

package/cli/helpers/axiosAuth.js

@@ -0,0 +1,12 @@
+const axios = require('axios');
+
+module.exports = (options) => {
+  return axios({
+    ...options,
+    // url: options.url.startsWith('http') ? options.url : `https://hive-api-test.paralect.co/${options.url}`,
+    url: options.url.startsWith('http') ? options.url : `http://localhost:3001/${options.url}`,
+    headers: { 
+      ...(options?.headers || {}),
+      ...(process.env.HIVE_TOKEN ? { Authorization: `Bearer ${process.env.HIVE_TOKEN}` } : {})}
+  })
+}

package/cli/helpers/downloadDirectory.js

@@ -0,0 +1,46 @@
+const path = require('path');
+const fs = require('fs-extra');
+const axios = require('axios');
+
+const GITHUB_API_URL = 'https://api.github.com/repos';
+
+async function fetchDirectoryTree(owner, repo, dirPath) {
+  const url = `${GITHUB_API_URL}/${owner}/${repo}/contents/${dirPath}`;
+  const response = await axios.get(url);
+  return response.data;
+}
+
+async function downloadFile(fileUrl, filePath) {
+  const response = await axios({
+    url: fileUrl,
+    method: 'GET',
+    responseType: 'stream'
+  });
+  await fs.ensureDir(path.dirname(filePath));
+  response.data.pipe(fs.createWriteStream(filePath));
+  return new Promise((resolve, reject) => {
+    response.data.on('end', resolve);
+    response.data.on('error', reject);
+  });
+}
+
+async function downloadDirectory(pluginName, baseDir = '') {
+  const owner = 'paralect';
+  const repo = 'hive-plugins';
+
+  const destDir = path.join(process.cwd(), baseDir);
+
+  const tree = await fetchDirectoryTree(owner, repo, pluginName);
+  for (const item of tree) {
+    const relativePath = path.relative(pluginName, item.path);
+    const filePath = path.join(destDir, relativePath);
+    if (item.type === 'file') {
+      console.log(`Downloading ${item.path}...`);
+      await downloadFile(item.download_url, filePath);
+    } else if (item.type === 'dir') {
+      await downloadDirectory(item.path, path.join(baseDir, relativePath));
+    }
+  }
+}
+
+module.exports = downloadDirectory;

package/cli/helpers/execCommand.js

@@ -0,0 +1,48 @@
+const fs = require('fs');
+const path = require('path');
+
+const execa = require('execa');
+const mkdirp = require('mkdirp');
+
+const execCommand = async (command, options = {}, outputFileSrc = null) => {
+  let commandParts = command;
+
+  if (typeof command === 'string') {
+    commandParts = command
+      .split(/ +(?=(?:(?:[^"]*"){2})*[^"]*$)/g)
+      .map((commandPart) => {
+        if (
+          commandPart[0] === '"' &&
+          commandPart[commandPart.length - 1] === '"'
+        ) {
+          return commandPart.replace(/["]+/g, '', '');
+        }
+
+        return commandPart;
+      });
+
+    // commandParts = command.split(' ').filter((part) => !!part.trim());
+  }
+
+  const commandName = commandParts.shift();
+  const commandArguments = commandParts;
+
+  const process = execa(commandName, commandArguments, {
+    stdio: outputFileSrc ? 'pipe' : 'inherit',
+    ...options,
+  });
+
+  if (outputFileSrc) {
+    console.log('writing to outputFileSrc', outputFileSrc);
+    const dir = path.dirname(outputFileSrc);
+
+    await mkdirp(dir);
+    console.log(dir, fs.existsSync(dir));
+
+    process.stdout.pipe(fs.createWriteStream(outputFileSrc, { flags: 'a+' }));
+  }
+
+  return process;
+};
+
+module.exports = execCommand;

package/cli/helpers/isAuthorized.js

@@ -0,0 +1,41 @@
+const axios = require('axios');
+const inquirer = require('inquirer');
+
+module.exports = async () => {
+  if (!process.env.HIVE_TOKEN) {
+    const { email } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'email',
+        message: 'Please enter your email:'
+      }
+    ]);
+
+    try {
+      await axios({ url: `https://hive-api-test.paralect.co/auth/login-code`, method: 'post', data: { email } });
+      
+      const { code } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'code',
+          message: `One time code (sent to ${email})`,
+        }
+      ]);
+
+      const { token, user } = (await axios({ url: `https://hive-api-test.paralect.co/auth/verify-login`, method: 'post', data: { email, code } })).data;
+
+      console.log(`
+        You're now logged into Hive! Welcome 🐝
+        
+        Important: to save access add HIVE_TOKEN to your env variables and your ~/.zshrc file
+
+        export HIVE_TOKEN=${token}`);
+
+      return { token, user }; 
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  } else {
+    return { token: process.env.HIVE_TOKEN };
+  }
+}

package/cli/helpers/isProjectInit.js

@@ -0,0 +1,71 @@
+const fs = require('fs');
+const path = require('path');
+const axios = require('./axiosAuth');
+const inquirer = require('inquirer');
+
+module.exports = async () => {
+  if (!process.env.PROJECT_ID) {
+    let projectConfigPath = path.resolve(process.env.HIVE_SRC, './hive.config.js');
+    
+    if (fs.existsSync(projectConfigPath)) {
+      const config = require(projectConfigPath);
+      if (config.projectId) {
+        process.env.PROJECT_ID = config.projectId;
+      }
+    } else {
+      const projectPackageJsonPath = path.resolve(process.env.HIVE_SRC, './package.json');
+      
+      let projectName;
+
+      if (fs.existsSync(projectPackageJsonPath)) {
+        const { name } = require(projectPackageJsonPath);
+        projectName = name;
+      } else {
+        const { name } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'name',
+            message: 'Project Name'
+          }
+        ]);
+
+        projectName = name;
+
+        fs.writeFileSync(projectPackageJsonPath, `${JSON.stringify({
+          name: name,
+
+          scripts: {
+            "dev": "nodemon --watch . --exec hive run .",
+          },
+
+          dependencies: {
+            "@paralect/hive": "^0.0.4"
+          },
+          devDependencies: {
+            "nodemon": "^3.1.4"
+          }
+        }, null, 2)}`);
+      }
+ 
+      const project = (await axios({ url: `projects`, method: 'post', data: { name: projectName } })).data;
+
+      fs.writeFileSync(projectConfigPath, `module.exports = { projectId: '${project._id}' } `);
+
+      const projectEnvPath = path.resolve(process.env.HIVE_SRC, './config/.env');
+      
+      if (project?.envs?.staging) {
+        if (!fs.existsSync(path.resolve(process.env.HIVE_SRC, './config'))) {
+          fs.mkdirSync(path.resolve(process.env.HIVE_SRC, './config'));
+        }
+
+        fs.writeFileSync(projectEnvPath, Object.keys(project.envs.staging).map(key => `${key}=${project.envs.staging[key]}`).join('\n'));
+      }
+
+      console.log(`Successfully initialised project ${projectName}!`);
+
+      process.env.PROJECT_ID = project._id;
+    }
+  }
+  
+  return { projectId: process.env.PROJECT_ID };
+}

package/cli/helpers/mergeDirs.js

@@ -0,0 +1,71 @@
+
+const fs = require('fs');
+const path = require('path');
+
+function shouldIgnore(filePath) {
+  const ignoredDirs = ['node_modules', 'dist', '.git'];
+  return ignoredDirs.some(dir => filePath.includes(path.sep + dir + path.sep));
+}
+
+async function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (let entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (shouldIgnore(srcPath)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      console.log('copy', srcPath, destPath)
+      await fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+async function copyRootFiles(sourceDir, destDir) {
+  try {
+    // Read all items in the source directory
+    const items = await fs.promises.readdir(sourceDir, { withFileTypes: true });
+
+    // Ensure the destination directory exists
+    await fs.promises.mkdir(destDir, { recursive: true });
+
+    // Iterate over each item
+    for (const item of items) {
+      const sourcePath = path.join(sourceDir, item.name);
+      const destPath = path.join(destDir, item.name);
+
+      // Check if the item is a file and not package.json
+      if (item.isFile() && item.name !== 'package.json') {
+        // Copy the file to the destination directory
+        await fs.promises.copyFile(sourcePath, destPath);
+        console.log(`Copied: ${sourcePath} -> ${destPath}`);
+      }
+    }
+
+    console.log('Files copied successfully.');
+  } catch (error) {
+    console.error('An error occurred:', error.message);
+  }
+}
+
+async function mergeDirectories(sourceDir1, sourceDir2, targetDir) {
+  // First, copy all contents from sourceDir1 to targetDir
+  await copyDir(sourceDir1, targetDir);
+
+  // Then, copy and extend/overwrite with contents from sourceDir2
+  await copyDir(sourceDir2, `${targetDir}/src`);
+  await copyRootFiles(sourceDir2, targetDir);
+}
+
+module.exports = async ({ hiveSrc, outDir }) => {
+  await mergeDirectories(path.resolve(__dirname, './../../starter'), hiveSrc, outDir);
+
+  console.log('Merged resources');
+}

package/cli/hive.js

@@ -1,50 +1,14 @@
 #!/usr/bin/env node
 
 const { program } = require('commander');
-const axios = require('axios');
-const fs = require('fs-extra');
-const path = require('path');
-
-const GITHUB_API_URL = 'https://api.github.com/repos';
 
-async function fetchDirectoryTree(owner, repo, dirPath) {
-  const url = `${GITHUB_API_URL}/${owner}/${repo}/contents/${dirPath}`;
-  const response = await axios.get(url);
-  return response.data;
-}
-
-async function downloadFile(fileUrl, filePath) {
-  const response = await axios({
-    url: fileUrl,
-    method: 'GET',
-    responseType: 'stream'
-  });
-  await fs.ensureDir(path.dirname(filePath));
-  response.data.pipe(fs.createWriteStream(filePath));
-  return new Promise((resolve, reject) => {
-    response.data.on('end', resolve);
-    response.data.on('error', reject);
-  });
-}
-
-async function downloadDirectory(pluginName, baseDir = '') {
-  const owner = 'paralect';
-  const repo = 'hive-plugins';
-
-  const destDir = path.join(process.cwd(), baseDir);
-
-  const tree = await fetchDirectoryTree(owner, repo, pluginName);
-  for (const item of tree) {
-    const relativePath = path.relative(pluginName, item.path);
-    const filePath = path.join(destDir, relativePath);
-    if (item.type === 'file') {
-      console.log(`Downloading ${item.path}...`);
-      await downloadFile(item.download_url, filePath);
-    } else if (item.type === 'dir') {
-      await downloadDirectory(item.path, path.join(baseDir, relativePath));
-    }
-  }
-}
+const path = require('path');
+const isAuthorized = require('./helpers/isAuthorized');
+const mergeDirs = require('./helpers/mergeDirs');
+const execCommand = require('./helpers/execCommand');
+const downloadDirectory = require('./helpers/downloadDirectory');
+const axios = require('./helpers/axiosAuth');
+const isProjectInit = require('./helpers/isProjectInit.js');
 
 program
   .command('run [dirPath]')
@@ -58,6 +22,66 @@ program
     }
   });
 
+  program
+  .command('deploy [imageTag]')
+  .description('Build and deploy Hive project from local machine docker + helm')
+  .action(async (imageTag) => {
+    process.env.HIVE_SRC = path.resolve(process.cwd());
+    
+    if (!imageTag) {
+      const { stdout: branch } = await execCommand(
+        "git rev-parse --abbrev-ref HEAD",
+        { stdio: "pipe" }
+      );
+      const { stdout: commitSHA } = await execCommand("git rev-parse HEAD", {
+        stdio: "pipe",
+      });
+
+      imageTag = `${branch}.${commitSHA}`;
+    }
+
+    console.log("Deploying Image Tag ", imageTag);
+
+    try {
+     await isAuthorized();
+    const { projectId } = await isProjectInit();
+    console.log('project id', projectId)
+     const { isOk } = (
+      await axios({ 
+        // url: `http://localhost:3001/projects/${projectId}/deploy`,
+        url: `projects/${projectId}/deploy`,
+        method: 'post',
+        data: {
+          imageTag
+        }
+      })
+      ).data;
+
+      console.log('Deployed');
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  });
+
+  program
+  .command('deploy-local')
+  .description('Build and deploy Hive project from local machine docker + helm')
+  .action(async () => {
+    try {
+      let outDir = path.resolve(process.cwd(), './dist');
+      await mergeDirs({ hiveSrc: path.resolve(process.cwd()), outDir });
+
+      console.log('outDir',  path.resolve(outDir, `./deploy/script`))
+      await execCommand(`npm install --prefix ${path.resolve(outDir, `./deploy/script`)}`);
+
+      await execCommand('node ./index.js', {
+        cwd: path.resolve(outDir, `./deploy/script/src`)
+      });
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  });
+
 program
   .command('install <plugin>')
   .description('Installs Hive plugin')
@@ -71,4 +95,95 @@ program
     }
   });
 
+program
+  .command('login')
+  .description('Login into Hive Cloud')
+  .action(async () => {
+    if (process.env.HIVE_TOKEN) {
+      const user = (await axios({ url: `users/me`, method: 'get' })).data;
+
+      console.log(`Already logged in!`, user);
+      
+      return;
+    }
+   
+  });
+
+program
+  .command('init')
+  .description('Init Hive Project')
+  .action(async () => {
+    try {
+      process.env.HIVE_SRC = path.resolve(process.cwd());
+
+      await isAuthorized();
+      await isProjectInit();
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  });
+
+program
+  .command('env-get <envName>')
+  .description('Get env variable')
+  .action(async (envName) => {
+    try {
+      process.env.HIVE_SRC = path.resolve(process.cwd());
+
+      await isAuthorized();
+      const { projectId } = await isProjectInit();
+
+      const { value } = (await axios({ 
+        method: 'post',
+        url: `projects/${projectId}/get-env`,
+        data: {
+          name: envName
+        }
+      })).data;
+
+      console.log(`${envName} value is ${value || '<empty>'}`)
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  });
+
+  program
+  .command('env-set <envName> <envValue>')
+  .description('Set env variable')
+  .action(async (envName, envValue) => {
+    try {
+      process.env.HIVE_SRC = path.resolve(process.cwd());
+
+      await isAuthorized();
+      const { projectId } = await isProjectInit();
+
+      const { value } = (await axios({ 
+        method: 'post',
+        url: `projects/${projectId}/env`,
+        data: {
+          name: envName,
+          value: envValue,
+        }
+      })).data;
+
+      console.log(`Updated ${envName}`)
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  });
+
+
+// program
+//   .command('init [name]')
+//   .description('Installs Hive plugin')
+//   .action(async (plugin) => {
+//     try {
+//       const destDir = process.cwd();
+      
+//       await downloadDirectory(plugin);
+//     } catch (error) {
+//       console.error('An error occurred:', error.message);
+//     }
+//   });
+
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paralect/hive",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -14,6 +14,8 @@
     "@koa/multer": "3.0.0",
     "@koa/router": "10.1.1",
     "@paralect/node-mongo": "2.1.1",
+    "@react-email/components": "^0.0.20",
+    "@react-email/render": "^0.0.16",
     "@sendgrid/mail": "7.6.1",
     "@socket.io/redis-adapter": "7.1.0",
     "@socket.io/redis-emitter": "4.1.1",
@@ -24,9 +26,11 @@
     "commander": "^12.1.0",
     "dotenv": "16.0.0",
     "eslint-config-prettier": "8.5.0",
+    "execa": "^4.1.0",
     "fs-extra": "^11.2.0",
     "handlebars": "4.7.7",
-    "joi": "17.6.0",
+    "inquirer": "^8.2.6",
+    "joi": "^17.13.3",
     "koa": "2.13.4",
     "koa-bodyparser": "4.3.0",
     "koa-helmet": "6.1.0",
@@ -35,11 +39,12 @@
     "koa-qs": "3.0.0",
     "lodash": "4.17.21",
     "mjml": "4.12.0",
-    "mkdirp": "1.0.4",
+    "mkdirp": "^1.0.4",
     "moment": "2.29.1",
     "moment-duration-format": "2.3.2",
     "multer": "1.4.4",
     "node-schedule": "2.1.0",
+    "nodemailer": "^6.9.14",
     "nodemon": "2.0.15",
     "prettier": "2.6.2",
     "psl": "1.8.0",

package/starter/.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["@babel/preset-env", "@babel/preset-react"]
+}

package/starter/.dockerignore

@@ -0,0 +1 @@
+node_modules

package/starter/Dockerfile

@@ -1,13 +1,22 @@
 FROM --platform=linux/amd64 node:16.13.1-alpine3.13 as base
 RUN apk add --no-cache python3 py3-pip
 
-# On staging containers running in development mode
-ARG NODE_ENV=development
+ENV NODE_ENV=production
+ENV APP_ENV=production
 
-ARG APP_ENV
-ENV NODE_ENV=$NODE_ENV
-ENV APP_ENV=$APP_ENV
+WORKDIR /app
+EXPOSE 3001
+COPY ["./package*.json", "/app/"]
 
-WORKDIR /project
+RUN npm set progress=false && npm config set depth 0
 
-CMD npm run dev 2>&1 | tee /project/logs/log.txt
+RUN npm set-script prepare ""
+
+RUN npm ci --only=production --quiet
+
+COPY ./ ./
+
+RUN mkdir -p /project/logs
+RUN touch /project/logs/log.txt
+
+CMD npm start 2>&1 | tee /project/logs/log.txt

package/starter/bin/deploy.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+cd "$( dirname "${BASH_SOURCE[0]}" )"
+cd ..
+
+node ./deploy/script/src/index.js

package/starter/deploy/api/Chart.yaml

@@ -0,0 +1,6 @@
+apiVersion: v2
+name: hive-api
+description: A Helm chart for Kubernetes
+type: application
+version: 0.1.0
+appVersion: 1.16.0

package/starter/deploy/api/staging.yaml

@@ -0,0 +1,3 @@
+nodePool: pool-app
+containerRegistry: paralect/hive-api
+port: 3001

package/starter/deploy/api/templates/deployment.yaml

@@ -0,0 +1,44 @@
+kind: Deployment
+apiVersion: apps/v1
+metadata:
+  name: {{ .Values.service }}
+  labels:
+    app: {{ .Values.service }}
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: {{ .Values.service }}
+  template:
+    metadata:
+      labels:
+        app: {{ .Values.service }}
+    spec:
+      restartPolicy: Always
+      containers:
+        - name: {{ .Values.service }}
+          image: {{ .Values.containerRegistry }}:{{ .Values.imagesVersion }}
+          env:
+            - name: PROJECT_ID
+              value: {{ .Values.projectId }}
+            {{- range .Values.env }}
+            - name: {{ .name }}
+              value: {{ .value }}
+            {{- end }}
+          imagePullPolicy: Always
+          livenessProbe:
+            httpGet:
+              path: /health
+              port: {{ .Values.port }}
+            initialDelaySeconds: 300
+            periodSeconds: 10
+          ports:
+            - containerPort: {{ .Values.port }}
+              protocol: TCP
+      nodeSelector:
+        doks.digitalocean.com/node-pool: {{ .Values.nodePool }}
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 0
+      maxSurge: 1

package/starter/deploy/api/templates/ingress.yaml

@@ -0,0 +1,26 @@
+kind: Ingress
+apiVersion: networking.k8s.io/v1
+metadata:
+  name: {{ .Values.service }}
+  labels:
+    app: {{ .Values.service }}
+  annotations:
+    nginx.ingress.kubernetes.io/proxy-read-timeout: "180"
+    nginx.ingress.kubernetes.io/proxy-body-size: "20m"
+    external-dns.alpha.kubernetes.io/hostname: {{ first .Values.domain }}
+    external-dns.alpha.kubernetes.io/ttl: "120" #optional
+spec:
+  ingressClassName: nginx
+  rules:
+  {{- range $domain := .Values.domain }}
+    - host: {{ $domain }}
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: {{ $.Values.service }}
+                port:
+                  number: {{ $.Values.port }}
+  {{- end}}