@paralect/hive 0.1.48 → 0.1.50-alpha.0

package/.hive/src/middlewares/shouldExist.js

@@ -0,0 +1,37 @@
+import db from '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]
+  );
+}
+
+export default (
+  resourceName,
+  {
+    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[ctxName] = doc;
+    ctx.state[singularize(resourceName)] = doc;
+
+    if (!doc) {
+      ctx.throw(404, { message: `${resourceName} not found` });
+    } else {
+      await next();
+    }
+  };
+};

package/.hive/src/middlewares/shouldNotExist.js

@@ -0,0 +1,19 @@
+import _ from 'lodash';
+import db from 'db';
+
+export default (
+  resourceName,
+  { criteria = (ctx) => ({ name: ctx.validatedData.name }) } = {}
+) => {
+  return async (ctx, next) => {
+    const doc = await db.services[resourceName].findOne(criteria(ctx));
+
+    if (doc) {
+      ctx.throw(400, {
+        message: `${_.capitalize(resourceName)} already exists`,
+      });
+    } else {
+      await next();
+    }
+  };
+};

package/.hive/src/middlewares/uploadFile.js

@@ -0,0 +1,5 @@
+import multer from '@koa/multer';
+
+const storage = multer.memoryStorage();
+
+export default multer({ storage });

package/.hive/src/middlewares/validate.js

@@ -0,0 +1,32 @@
+
+const formatError = (zodError) => {
+  const errors = {};
+
+  zodError.issues.forEach((error) => {
+    const key = error.path.join('.');
+
+    if (!errors[key]) {
+      errors[key] = [];
+    }
+
+    (errors[key]).push(error.message);
+  });
+
+  return errors;
+};
+
+const validate = (schema) => async (ctx, next) => {
+  const result = await schema.passthrough().safeParseAsync({
+    ...(ctx.request.body),
+    ...ctx.query,
+    ...ctx.params,
+  });
+
+  if (!result.success) ctx.throw(400, { clientErrors: formatError(result.error) });
+
+  ctx.validatedData = result.data;
+
+  await next();
+};
+
+export default validate;

package/.hive/src/migrations/migration.js

@@ -0,0 +1,8 @@
+class Migration {
+  constructor(version, description) {
+    this.version = version;
+    this.description = description;
+  }
+}
+
+export default Migration;

package/.hive/src/migrations/migration.service.js

@@ -0,0 +1,73 @@
+import db from "db";
+import fs from "fs";
+import path from "path";
+import _ from "lodash";
+import validateSchema from "./migrations.schema";
+
+const service = db.createService("__migrationVersion", {
+  validate: validateSchema,
+});
+
+const migrationsPath = path.join(__dirname, "migrations");
+
+const _id = "migration_version";
+
+const getMigrationNames = () =>
+  new Promise((resolve, reject) => {
+    fs.readdir(migrationsPath, (err, files) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(files);
+    });
+  });
+
+service.getCurrentMigrationVersion = () =>
+  service.findOne({ _id }).then((doc) => {
+    if (!doc) {
+      return 0;
+    }
+    return doc.version;
+  });
+
+service.getMigrations = () => {
+  let migrations = null;
+  return getMigrationNames()
+    .then((names) => {
+      migrations = names.map((name) => {
+        const migrationPath = path.join(migrationsPath, name);
+        // eslint-disable-next-line import/no-dynamic-require, global-require
+        // return require(migrationPath);
+      });
+      return migrations;
+    })
+    .catch((err) => {
+      throw err;
+    });
+};
+
+service.setNewMigrationVersion = (version) =>
+  service.atomic.findOneAndUpdate(
+    { _id },
+    {
+      $set: {
+        version,
+      },
+      $setOnInsert: {
+        _id,
+      },
+    },
+    { upsert: true }
+  );
+
+service.promiseLimit = (documents = [], limit, operator) => {
+  const chunks = _.chunk(documents, limit);
+  return chunks.reduce((init, chunk) => {
+    return init.then(() => {
+      return Promise.all(chunk.map((c) => operator(c)));
+    });
+  }, Promise.resolve());
+};
+
+export default service;

package/.hive/src/migrations/migrations/1.js

@@ -0,0 +1,22 @@
+import Migration from 'migrations/migration';
+// const migrationService = require('migrations/migration.service');
+//
+// const userService = require('resources/user/user.service');
+
+const migration = new Migration(1, "Example");
+
+migration.migrate = async () => {
+  // const userIds = await userService.distinct('_id', {
+  //   isEmailVerified: true,
+  // });
+  //
+  // await migrationService.promiseLimit(userIds, 50, (userId) => userService.updateOne(
+  //   { _id: userId },
+  //   (old) => ({
+  //     ...old,
+  //     isEmailVerified: false,
+  //   }),
+  // ));
+};
+
+export default migration;

package/.hive/src/migrations/migrations-log/migration-log.schema.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
+
+export default dbSchema.extend({
+  startTime: z.date(),
+  finishTime: z.date().optional(),
+  status: z.string(),
+  error: z.string().optional(),
+  errorStack: z.string().optional(),
+  duration: z.string().optional(),
+  migrationVersion: z.number(),
+});
+

package/.hive/src/migrations/migrations-log/migration-log.service.js

@@ -0,0 +1,50 @@
+import db from 'db';
+import validateSchema from './migration-log.schema.js';
+
+const service = db.createService("__migrationLog", {
+  validate: validateSchema,
+});
+
+service.startMigrationLog = (_id, startTime, migrationVersion) => {
+  return service.atomic.findOneAndUpdate(
+    { _id },
+    {
+      $set: {
+        migrationVersion,
+        startTime,
+        status: "running",
+      },
+      $setOnInsert: {
+        _id,
+      },
+    },
+    { upsert: true }
+  );
+};
+
+service.failMigrationLog = (_id, finishTime, err) =>
+  service.atomic.update(
+    { _id },
+    {
+      $set: {
+        finishTime,
+        status: "failed",
+        error: err.message,
+        errorStack: err.stack,
+      },
+    }
+  );
+
+service.finishMigrationLog = (_id, finishTime, duration) =>
+  service.atomic.update(
+    { _id },
+    {
+      $set: {
+        finishTime,
+        status: "completed",
+        duration,
+      },
+    }
+  );
+
+export default service;

package/.hive/src/migrations/migrations.schema.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
+
+export default dbSchema.extend({
+  version: z.number(),
+});

package/.hive/src/migrations/migrator.js

@@ -0,0 +1,75 @@
+import 'moment-duration-format';
+import moment from 'moment';
+import logger from 'logger';
+import migrationLogService from './migrations-log/migration-log.service';
+import migrationService from './migration.service';
+
+const migrator = {};
+
+const run = async (migrations, curVersion) => {
+  const newMigrations = migrations
+    .filter((migration) => migration.version > curVersion)
+    .sort((a, b) => a.version - b.version);
+
+  if (!newMigrations.length) {
+    logger.info(`No new migrations found, stopping the process.
+      Current database version is ${curVersion}`);
+    return;
+  }
+
+  let migrationLogId;
+  let migration;
+  let lastMigrationVersion;
+
+  try {
+    for (migration of newMigrations) {
+      //eslint-disable-line
+      migrationLogId = migrationService.generateId();
+      const startTime = new Date();
+      await migrationLogService.startMigrationLog(
+        migrationLogId,
+        startTime,
+        migration.version
+      ); //eslint-disable-line
+      logger.info(
+        `Migration #${migration.version} is running: ${migration.description}`
+      );
+      await migration.migrate(); //eslint-disable-line
+
+      lastMigrationVersion = migration.version;
+      await migrationService.setNewMigrationVersion(migration.version); //eslint-disable-line
+      const finishTime = new Date();
+      const duration = moment
+        .duration(finishTime - startTime)
+        .format("h [hrs], m [min], s [sec], S [ms]");
+
+      await migrationLogService.finishMigrationLog(
+        migrationLogId,
+        finishTime,
+        duration
+      ); //eslint-disable-line
+      logger.info(
+        `Database has been updated to the version #${migration.version}`
+      );
+      logger.info(`Time of migration #${migration.version}: ${duration}`);
+    }
+    logger.info(`All migrations has been finished, stopping the process.
+      Current database version is: ${lastMigrationVersion}`);
+  } catch (err) {
+    logger.error(`Failed to update migration to version ${migration.version}`);
+    logger.error(err);
+    await migrationLogService.failMigrationLog(migrationLogId, new Date(), err);
+    throw err;
+  }
+};
+
+migrator.exec = async () => {
+  const [migrations, currentVersion] = await Promise.all([
+    migrationService.getMigrations(),
+    migrationService.getCurrentMigrationVersion(),
+  ]);
+  await run(migrations, currentVersion);
+  process.exit(0);
+};
+
+export default migrator;

package/.hive/src/migrator.js

@@ -0,0 +1,4 @@
+import appModulePath from "app-module-path";
+import migrator from "migrations/migrator";
+appModulePath.addPath(__dirname);
+migrator.exec();

package/.hive/src/resources/_dev/endpoints/triggerSchedulerHandler.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+export const endpoint = {
+  method: "put",
+  url: "/trigger-scheduler-handler",
+};
+
+export const requestSchema = z.object({
+  name: z.string(),
+});
+
+export const handler = async (ctx) => {
+  const { name } = ctx.validatedData;
+
+  const schedulerHandler = await (import(`${process.env.HIVE_SRC}/scheduler/handlers/${name}`));
+
+  try {
+    const data = await schedulerHandler.handler();
+
+    ctx.body = {
+      ok: true,
+      data,
+    };
+  } catch (err) {
+    ctx.body = {
+      ok: false,
+      err: err.message,
+    };
+  }
+};
+
+export const middlewares = ['allowNoAuth'];

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

@@ -0,0 +1,19 @@
+import { render } from '@react-email/render';
+import { MyEmailComponent } from 'emails/compiled/MyEmailComponent';
+import React from 'react';
+
+export const handler = (ctx) => {
+  const emailHtml = render(React.createElement(MyEmailComponent, { name: 'test' }));
+
+  ctx.body = emailHtml;
+  ctx.status = 200;
+};
+
+export const endpoint = {
+  method: "get",
+  url: "/",
+};
+
+export default {
+  handler, endpoint
+}

package/.hive/src/resources/schemaMappings/schemaMappings.schema.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
+
+export default dbSchema.extend({
+  mappings: z.object({}),
+});

package/.hive/src/resources/tokens/methods/generateSecureToken.js

@@ -0,0 +1,9 @@
+import crypto from 'crypto';
+import util from 'util';
+
+const randomBytes = util.promisify(crypto.randomBytes, crypto);
+
+export default async (tokenLength = 32) => {
+  const buf = await randomBytes(tokenLength);
+  return buf.toString('hex');
+};

package/.hive/src/resources/tokens/methods/setToken.js

@@ -0,0 +1,8 @@
+import db from 'db';
+const tokenService = db.services.tokens;
+
+export default async () => {
+  const { results } = await tokenService.aggregate([]);
+
+  return results;
+};

package/.hive/src/resources/tokens/methods/storeToken.js

@@ -0,0 +1,35 @@
+import db from 'db';
+import crypto from 'crypto';
+import util from 'util';
+
+const randomBytes = util.promisify(crypto.randomBytes, crypto);
+
+import setCookie from 'services/setCookie';
+
+const tokenService = db.services.tokens;
+
+const generateSecureToken = async (tokenLength = 32) => {
+  const buf = await randomBytes(tokenLength);
+  return buf.toString('hex');
+};
+
+export default async (ctx, { userId, metadata = null }) => {
+  const token = await generateSecureToken();
+  const otp = await generateSecureToken();
+
+  await tokenService.create({
+    token,
+    user: {
+      _id: userId,
+    },
+    otp,
+    ...(metadata ? { metadata } : {})
+  });
+
+  setCookie(ctx, { name: 'access_token', value: token });
+
+  return {
+    token,
+    otp,
+  };
+};

package/.hive/src/resources/tokens/tokens.schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
+
+export default dbSchema.extend({
+  user: z.object({
+    _id: z.string(),
+  }),
+  token: z.string(),
+  otp: z.string().nullable().optional(),
+  metadata: z.object({}).optional()
+});

package/.hive/src/resources/users/endpoints/getCurrentUser.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import isAuthorized from 'middlewares/isAuthorized';
+
+export const handler = async (ctx) => {
+  ctx.body = ctx.state.user;
+};
+
+export const middlewares = [isAuthorized];
+export const requestSchema = z.object({});
+
+export const endpoint = {
+  method: "GET",
+  url: "/me",
+};

package/.hive/src/resources/users/endpoints/getUserProfile.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import db from 'db';
+
+const userService = db.services.users;
+
+export const handler = async (ctx) => {
+  const { userId } = ctx.params;
+  const user = await userService.findOne({ _id: userId });
+  ctx.body = user;
+};
+
+export const requestSchema = z.object({
+  userId: z.string(),
+});
+
+export const endpoint = {
+  method: "GET",
+  url: "/profile/:userId",
+};

package/.hive/src/resources/users/handlers/test.js

@@ -0,0 +1 @@
+console.log('hello from handler');

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

@@ -0,0 +1,68 @@
+import db from 'db';
+import _ from 'lodash';
+import slug from 'slug';
+
+const userService = db.services.users;
+
+const formatUsername = ({ username, fullName, email }) => {
+  return (
+    username ||
+    fullName ? slug(`${fullName.split(' ')[0]} ${fullName.split(' ')[1] || ''}`, '.') : email?.split('@')[0]
+  );
+};
+
+const createUserAccount = async (userData) => {
+  let username = formatUsername({ fullName: userData.fullName, email: userData.email });
+
+  if (await userService.exists({ username })) {
+    username += _.random(1000, 9999);
+  }
+
+  const user = await userService.create({
+    fullName: userData.fullName,
+    username,
+    email: userData.email,
+    isEmailVerified: true,
+    avatarUrl: userData.avatarUrl,
+    oauth: userData.oauth,
+  });
+
+  return user;
+};
+
+const ensureUserCreated = async (userData) => {
+  const user = await userService.findOne({ email: userData.email });
+
+  if (user) {
+    if (userData.oauth) {
+      const changedUser = await userService.updateOne(
+        { _id: user._id },
+        (old) => {
+          const newUser = old;
+          newUser.oauth = old.oauth || {};
+          newUser.oauth = {
+            ...newUser.oauth,
+            ...userData.oauth
+          }
+          newUser.isEmailVerified = true;
+
+          return newUser;
+        }
+      );
+
+     return { user: changedUser, isNew: false };
+    } else {
+      return { user, isNew: false };
+    }
+  }
+
+  return {
+    user: await createUserAccount(userData),
+    isNew: true,
+  };
+};
+
+export default async (userData) => {
+  const { user, isNew } = await ensureUserCreated(userData);
+  return user;
+};

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema';
+
+const users = dbSchema.extend({
+  email: z.string().email(),
+  fullName: z.string(),
+  avatarUrl: z.string().url().optional(),
+
+  password: z.string(),
+
+  oauth: z.object({
+    google: z.object({}),
+  }).optional(),
+});
+
+export default users;