@paralect/hive 0.1.49 → 0.1.50-alpha.2

package/.hive/deploy/script/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "deploy",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "execa": "4.0.0",
+    "prompt-list": "3.2.0"
+  }
+}

package/.hive/deploy/script/src/config.js

@@ -0,0 +1,48 @@
+const path = require("path");
+const rootDir = path.resolve(__dirname, "./../../../");
+
+const ENV = process.env;
+
+const config = {
+  rootDir,
+
+  environment: ENV.ENVIRONMENT || "staging",
+
+  namespace: ENV.NAMESPACE || "staging",
+
+  kubeConfig: ENV.KUBE_CONFIG,
+
+  home: ENV.HOME,
+
+  dockerRegistry: {
+    name: "paralect/hive-api",
+    username: ENV.DOCKER_AUTH_USERNAME,
+    password: ENV.DOCKER_AUTH_PASSWORD,
+
+    imageTag: ENV.IMAGE_TAG,
+  },
+};
+
+const deployConfig = {
+  dockerRepo: `${config.dockerRegistry.name}`,
+  dir: `${rootDir}`,
+  folder: "",
+  dockerFilePath: `${rootDir}/Dockerfile`,
+  dockerContextDir: rootDir
+};
+
+// Object.keys(deployConfig).forEach((serviceName) => {
+//   if (!deployConfig[serviceName].dockerFilePath) {
+//     deployConfig[
+//       serviceName
+//     ].dockerFilePath = `${deployConfig[serviceName].dir}/Dockerfile`;
+//   }
+
+//   if (!deployConfig[serviceName].dockerContextDir) {
+//     deployConfig[serviceName].dockerContextDir = deployConfig[serviceName].dir;
+//   }
+// });
+
+config.deploy = deployConfig;
+
+module.exports = config;

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

@@ -0,0 +1,108 @@
+const fs = require("fs");
+const List = require("prompt-list");
+
+const config = require("./config");
+const { execCommand } = require("./util");
+
+
+const buildAndPushImage = async ({
+  dockerFilePath,
+  dockerRepo,
+  dockerContextDir,
+  imageTag,
+  environment,
+}) => {
+  await execCommand(`docker build \
+    --build-arg APP_ENV=${environment} \
+    -f ${dockerFilePath} \
+    -t ${dockerRepo} \
+    ${dockerContextDir}`);
+  await execCommand(`docker tag ${dockerRepo} ${imageTag}`);
+  await execCommand(`docker push ${imageTag}`);
+  await execCommand(`docker push ${dockerRepo}:latest`);
+};
+
+const pushToKubernetes = async ({ imageTag, appName, deployConfig }) => {
+  const deployDir = `${config.rootDir}/deploy/api`;
+
+  if (config.kubeConfig && !fs.existsSync(`${config.home}/.kube/config`)) {
+    console.log("Creating kubeconfig");
+    fs.mkdirSync(`${config.home}/.kube`);
+    fs.writeFileSync(`${config.home}/.kube/config`, config.kubeConfig);
+  }
+
+  let projectId = process.env.PROJECT_ID || 'core';
+  let attachedDomains;
+
+  await execCommand(
+    `helm upgrade --force --install projects-${projectId} ${deployDir} \
+      --namespace apps --create-namespace  \
+      --set containerRegistry=paralect/hive-api \
+      --set service=hive-api-${projectId} \
+      --set imagesVersion=${imageTag}  \
+      --set domain={hive-api-${projectId}.paralect.co} \
+      --set projectId=${projectId} \
+      --set env\[0\].name=MONGODB_URI \
+      --set env\[0\].value='${process.env.MONGODB_URI}' \
+      -f ${deployDir}/staging.yaml   --timeout 35m`,
+    {
+      // cwd: `/app`,
+    }
+  );
+};
+
+const deploy = async () => {
+  if (config.dockerRegistry.password) {
+    await execCommand(
+      `docker login --username ${config.dockerRegistry.username} --password ${config.dockerRegistry.password} registry.digitalocean.com`
+    );
+  }
+  const deployConfig = config.deploy;
+
+  let imageTag = config.dockerRegistry.imageTag;
+
+  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}`;
+  }
+
+  try {
+    await execCommand(
+      "kubectl delete secrets sh.helm.release.v1.apps-staging-api.v1"
+    );
+
+    await execCommand(
+      "kubectl delete secrets sh.helm.release.v1.apps-staging-api.v2"
+    );
+  } catch (err) {}
+
+  // push api image to registry
+  await buildAndPushImage({
+    ...deployConfig,
+    imageTag: `${deployConfig.dockerRepo}:${imageTag}`,
+    environment: config.environment,
+  });
+
+  if (!process.env.SKIP_KUBERNETES) {
+    // deploy api to kubernetes and deploy migrator through helm hooks
+    await pushToKubernetes({
+      imageTag,
+      appName: "api",
+      deployConfig,
+    });
+  }
+};
+
+deploy();
+
+process.on("unhandledRejection", (error) => {
+  console.error(error);
+  process.exit(1);
+});

package/.hive/deploy/script/src/util.js

@@ -0,0 +1,19 @@
+const execa = require('execa');
+
+const execCommand = async (command, options = {}) => {
+  let commandParts = command;
+
+  if (typeof command === 'string') {
+    commandParts = command.split(' ').filter(part => !!part.trim());
+  }
+
+  const commandName = commandParts.shift();
+  const commandArguments = commandParts;
+  console.log('command', command);
+
+  return execa(commandName, commandArguments, { stdio: 'inherit', ...options });
+};
+
+module.exports = {
+  execCommand,
+};

package/.hive/initial-data.json

@@ -0,0 +1,176 @@
+{
+  "resources": [
+    {
+      "name": "users",
+      "endpoints": [
+        {
+          "name": "getCurrentUser",
+          "endpoint": { "method": "GET", "url": "/me" },
+          "requestSchema": {},
+          "handler": "module.exports.handler = async (ctx) => { const user = await userService.findOne({ _id: ctx.state.user._id }); ctx.body = user; }"
+        },
+        {
+          "name": "getUserProfile",
+          "endpoint": { "method": "GET", "url": "/profile/:userId" },
+          "requestSchema": {
+            "userId": "Joi.string().required()"
+          },
+          "handler": "module.exports.handler = async (ctx) => { const { userId } = ctx.params; const user = await userService.findOne({ _id: userId }); ctx.body = user; }"
+        }
+      ],
+      "handlers": [],
+      "methods": [],
+      "schemas": [
+        {
+          "name": "users",
+          "schema": {
+            "username": "Joi.string().required()",
+            "email": "Joi.string().email().required()",
+            "password": "Joi.string().required()",
+            "bio": "Joi.string()",
+            "avatarUrl": "Joi.string().uri()",
+            "_id": "Joi.string()",
+            "createdOn": "Joi.date()",
+            "updatedOn": "Joi.date()"
+          },
+          "_schemaMappings": {}
+        }
+      ]
+    },
+    {
+      "name": "follows",
+      "endpoints": [
+        {
+          "name": "followUser",
+          "endpoint": { "method": "POST", "url": "/" },
+          "requestSchema": {
+            "followingId": "Joi.string().required()"
+          },
+          "handler": "module.exports.handler = async (ctx) => { const { followingId } = ctx.validatedData; const followerId = ctx.state.user._id; const newFollow = await followService.create({ follower: { _id: followerId }, following: { _id: followingId } }); ctx.body = newFollow; }"
+        },
+        {
+          "name": "unfollowUser",
+          "endpoint": { "method": "DELETE", "url": "/" },
+          "requestSchema": {
+            "followingId": "Joi.string().required()"
+          },
+          "handler": "module.exports.handler = async (ctx) => { const { followingId } = ctx.validatedData; const followerId = ctx.state.user._id; await followService.remove({ follower: { _id: followerId }, following: { _id: followingId } }); ctx.body = { message: 'Unfollowed successfully' }; }"
+        }
+      ],
+      "handlers": [
+        {
+          "name": "updateFollowersCount",
+          "handler": "const userService = require('../../../db').services.users; const followService = require('../../../db').services.follows; followService.on('created', async ({ doc: follow }) => { const { followingId } = follow; await userService.atomic.update({ _id: followingId }, { $inc: { followersCount: 1 } }); }); followService.on('removed', async ({ doc: follow }) => { const { followingId } = follow; await userService.atomic.update({ _id: followingId }, { $inc: { followersCount: -1 } }); });"
+        }
+      ],
+      "methods": [],
+      "schemas": [
+        {
+          "name": "follows",
+          "schema": {
+            "follower": { "_id": "Joi.string().required()" },
+            "following": { "_id": "Joi.string().required()" },
+            "_id": "Joi.string()",
+            "createdOn": "Joi.date()",
+            "updatedOn": "Joi.date()"
+          },
+          "_schemaMappings": {}
+        }
+      ]
+    },
+    {
+      "name": "posts",
+      "endpoints": [
+        {
+          "name": "createPost",
+          "endpoint": { "method": "POST", "url": "/" },
+          "requestSchema": {
+            "content": "Joi.string().max(280).required()",
+            "fileUrl": "Joi.string().allow(null, '')"
+          },
+          "handler": "module.exports.handler = async (ctx) => { const { content, fileUrl } = ctx.validatedData; const userId = ctx.state.user._id; const username = ctx.state.user.username; const newPost = await postService.create({ content, fileUrl, creator: { _id: userId, username: username } }); ctx.body = newPost; }"
+        },
+        {
+          "name": "getFeed",
+          "endpoint": { "method": "GET", "url": "/feed" },
+          "requestSchema": {},
+          "handler": "module.exports.handler = async (ctx) => { const posts = await postService.find({}, { sort: { createdOn: -1 } }); ctx.body = posts; }"
+        },
+        {
+          "name": "likePost",
+          "endpoint": { "method": "POST", "url": "/:postId/like" },
+          "requestSchema": {},
+          "handler": "module.exports.handler = async (ctx) => { const { postId } = ctx.params; const userId = ctx.state.user._id; await likeService.create({ post: { _id: postId }, user: { _id: userId } }); await postService.atomic.update({ _id: postId }, { $inc: { likesCount: 1 } }); ctx.body = { message: 'Post liked' }; }"
+        },
+        {
+          "name": "commentOnPost",
+          "endpoint": { "method": "POST", "url": "/:postId/comment" },
+          "requestSchema": {
+            "content": "Joi.string().required()"
+          },
+          "handler": "module.exports.handler = async (ctx) => { const { postId } = ctx.params; const { content } = ctx.validatedData; const userId = ctx.state.user._id; const username = ctx.state.user.username; const newComment = await commentService.create({ post: { _id: postId }, content, creator: { _id: userId, username: username }, createdOn: new Date() }); await postService.atomic.update({ _id: postId }, { $inc: { commentsCount: 1 } }); ctx.body = newComment; }"
+        }
+      ],
+      "handlers": [
+        {
+          "name": "updateCommentsCount",
+          "handler": "const postService = require('../../../db').services.posts; const commentService = require('../../../db').services.comments; commentService.on('created', async ({ doc: comment }) => { const { post } = comment; await postService.atomic.update({ _id: post._id }, { $inc: { commentsCount: 1 } }); }); commentService.on('removed', async ({ doc: comment }) => { const { post } = comment; await postService.atomic.update({ _id: post._id }, { $inc: { commentsCount: -1 } }); });"
+        },
+        {
+          "name": "updateLikesCount",
+          "handler": "const postService = require('../../../db').services.posts; const likeService = require('../../../db').services.likes; likeService.on('created', async ({ doc: like }) => { const { postId } = like; await postService.atomic.update({ _id: postId }, { $inc: { likesCount: 1 } }); }); likeService.on('removed', async ({ doc: like }) => { const { postId } = like; await postService.atomic.update({ _id: postId }, { $inc: { likesCount: -1 } }); });"
+        },
+        {
+          "name": "notifyUserOnComment",
+          "handler": ""
+        }
+      ],
+      "methods": [],
+      "schemas": [
+        {
+          "name": "posts",
+          "schema": {
+            "content": "Joi.string().max(280).required()",
+            "fileUrl": "Joi.string().allow(null, '')",
+            "creator": {
+              "_id": "Joi.string().required()",
+              "username": "Joi.string()"
+            },
+            "likesCount": "Joi.number().default(0)",
+            "commentsCount": "Joi.number().default(0)",
+            "parentPost": {
+              "_id": "Joi.string()",
+              "content": "Joi.string()",
+              "creator": "Joi.object()",
+              "likesCount": "Joi.number().default(0)",
+              "commentsCount": "Joi.number().default(0)"
+            },
+            "_id": "Joi.string()",
+            "createdOn": "Joi.date()",
+            "updatedOn": "Joi.date()"
+          },
+          "_schemaMappings": {}
+        }
+      ]
+    },
+    {
+      "name": "likes",
+      "endpoints": [],
+      "handlers": [],
+      "methods": [],
+      "schemas": [
+        {
+          "name": "likes",
+          "schema": {
+            "post": { "_id": "Joi.string().required()" },
+            "user": { "_id": "Joi.string().required()" },
+            "_id": "Joi.string()",
+            "createdOn": "Joi.date()",
+            "updatedOn": "Joi.date()"
+          },
+          "_schemaMappings": {}
+        }
+      ]
+    }
+  ]
+}