@paralect/hive 0.0.3 → 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.3",
+  "version": "0.0.4",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -26,8 +26,10 @@
     "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",
+    "inquirer": "^8.2.6",
     "joi": "^17.13.3",
     "koa": "2.13.4",
     "koa-bodyparser": "4.3.0",
@@ -37,7 +39,7 @@
     "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",

package/starter/.dockerignore

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

package/starter/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:16.13.1-alpine3.13 as base
+FROM --platform=linux/amd64 node:16.13.1-alpine3.13 as base
 RUN apk add --no-cache python3 py3-pip
 
 ENV NODE_ENV=production

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

@@ -21,9 +21,10 @@ spec:
           env:
             - name: PROJECT_ID
               value: {{ .Values.projectId }}
-          env:
-            - name: MONGODB_URI
-              value: {{ .Values.mongoDbUri }}
+            {{- range .Values.env }}
+            - name: {{ .name }}
+              value: {{ .value }}
+            {{- end }}
           imagePullPolicy: Always
           livenessProbe:
             httpGet:

package/starter/deploy/script/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:16.13.1-alpine3.13
+FROM --platform=linux/amd64 node:16.13.1-alpine3.13
 
 RUN apk add docker
 

package/starter/deploy/script/src/index.js

@@ -31,7 +31,7 @@ const pushToKubernetes = async ({ imageTag, appName, deployConfig }) => {
     fs.writeFileSync(`${config.home}/.kube/config`, config.kubeConfig);
   }
 
-  let projectId = 'test';
+  let projectId = process.env.PROJECT_ID || 'core';
   let attachedDomains;
 
   await execCommand(
@@ -42,10 +42,11 @@ const pushToKubernetes = async ({ imageTag, appName, deployConfig }) => {
       --set imagesVersion=${imageTag}  \
       --set domain={hive-api-${projectId}.paralect.co} \
       --set projectId=${projectId} \
-      --set mongoDbUri='${process.env.MONGODB_URI}'
+      --set env\[0\].name=MONGODB_URI \
+      --set env\[0\].value='${process.env.MONGODB_URI}' \
       -f ${deployDir}/staging.yaml   --timeout 35m`,
     {
-      cwd: `/app`,
+      // cwd: `/app`,
     }
   );
 };

package/starter/package.json

@@ -17,7 +17,7 @@
   },
   "scripts": {
     "build-assets": "mjml ./src/assets/emails/*.mjml -o ./src/assets/emails/dist/",
-    "build-emails": "babel src/emails --out-dir src/emails/dist",
+    "build-emails": "babel src/emails --out-dir src/emails/compiled",
     "dev": "nodemon --watch src src/app.js",
     "init-project": "./bin/init-project.sh",
     "start": "node src/app.js",

package/starter/src/helpers/getResourceEndpoints.js

@@ -20,7 +20,6 @@ module.exports = async (resourceName) => {
     )).map( f => ({ name: f }))];
   }
 
-  console.log('endpointFiles', resourceName, endpointFiles);
   return endpointFiles.map(({ name, isHiveEndpoint }) => ({
     file: isHiveEndpoint ?  `${process.env.HIVE_SRC}/resources/${resourceName}/endpoints/${name}`: `${__dirname}/../resources/${resourceName}/endpoints/${name}`,
     name: _.last(name.split("/")).replace(".js", ""),

package/starter/src/middlewares/shouldExist.js

@@ -1,12 +1,32 @@
-const db = require("db");
+const db = require('db');
+
+function singularize(word) {
+  const endings = {
+    ves: 'fe',
+    ies: 'y',
+    i: 'us',
+    zes: 'ze',
+    ses: 's',
+    es: 'e',
+    s: '',
+  };
+  return word.replace(
+    new RegExp(`(${Object.keys(endings).join('|')})$`),
+    (r) => endings[r]
+  );
+}
 
 module.exports = (
   resourceName,
-  { criteria = (ctx) => ({ _id: ctx.params[`${resourceName}Id`] }) } = {}
+  {
+    criteria = (ctx) => ({ _id: ctx.params[`${singularize(resourceName)}Id`] }),
+    ctxName = resourceName,
+  } = {}
 ) => {
   return async (ctx, next) => {
     const doc = await db.services[resourceName].findOne(criteria(ctx));
-    ctx.state[resourceName] = doc;
+    ctx.state[ctxName] = doc;
+    ctx.state[singularize(resourceName)] = doc;
 
     if (!doc) {
       ctx.throw(404, { message: `${resourceName} not found` });
@@ -14,4 +34,4 @@ module.exports = (
       await next();
     }
   };
-};
+};

package/starter/src/resources/health/endpoints/get.js

@@ -1,5 +1,5 @@
 const { render } = require('@react-email/render');
-const { MyEmailComponent } = require('emails/dist/MyEmailComponent'); 
+const { MyEmailComponent } = require('emails/compiled/MyEmailComponent'); 
 const React = require('react');
 
 const handler = (ctx) => {

package/starter/src/resources/users/methods/ensureUserCreated.js

@@ -3,15 +3,15 @@ const slug = require('slug');
 
 const userService = require('db').services.users;
 
-const formatUsername = ({ username, fullName }) => {
+const formatUsername = ({ username, fullName, email }) => {
   return (
     username ||
-    slug(`${fullName.split(' ')[0]} ${fullName.split(' ')[1] || ''}`, '.')
+    fullName ? slug(`${fullName.split(' ')[0]} ${fullName.split(' ')[1] || ''}`, '.') : email?.split('@')[0]
   );
 };
 
 const createUserAccount = async (userData) => {
-  let username = formatUsername({ fullName: userData.fullName });
+  let username = formatUsername({ fullName: userData.fullName, email: userData.email });
 
   if (await userService.exists({ username })) {
     username += _.random(1000, 9999);
@@ -49,9 +49,9 @@ const ensureUserCreated = async (userData) => {
         }
       );
 
-     return { user: changedUser, isNew: true };
+     return { user: changedUser, isNew: false };
     } else {
-      throw new Error(`User with email ${userData.email} already exists`);
+      return { user, isNew: false };
     }
   }
 
@@ -62,6 +62,6 @@ const ensureUserCreated = async (userData) => {
 };
 
 module.exports = async (userData) => {
-  const { updatedUser, isNew } = await ensureUserCreated(userData);
-  return updatedUser;
+  const { user, isNew } = await ensureUserCreated(userData);
+  return user;
 };

package/starter/src/resources/users/users.schema.js

@@ -6,8 +6,8 @@ const users = Joi.object({
   updatedOn: Joi.date(),
 
   email: Joi.string().email().required(),
-  fullName: Joi.string().required(),
   username: Joi.string().required(),
+  fullName: Joi.string(),
   avatarUrl: Joi.string().uri(),
 
   password: Joi.string(),