@nlabs/reaktor 0.4.0 → 0.4.1

package/lib/actions/users.js

@@ -0,0 +1,571 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  UserAccess: () => UserAccess,
+  addUser: () => addUser,
+  confirmCode: () => confirmCode,
+  createToken: () => createToken,
+  deactivateUser: () => deactivateUser,
+  deleteUser: () => deleteUser,
+  getActiveUserCount: () => getActiveUserCount,
+  getDisplayName: () => getDisplayName,
+  getSessionUser: () => getSessionUser,
+  getUser: () => getUser,
+  getUserOptional: () => getUserOptional,
+  getUsers: () => getUsers,
+  getUsersByLatest: () => getUsersByLatest,
+  getUsersByReactions: () => getUsersByReactions,
+  getUsersByTags: () => getUsersByTags,
+  parseUserOptions: () => parseUserOptions,
+  refreshSession: () => refreshSession,
+  signIn: () => signIn,
+  signOut: () => signOut,
+  updateUser: () => updateUser
+});
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_isEmpty = __toModule(require("lodash/isEmpty"));
+var import_luxon = __toModule(require("luxon"));
+var import_stripe = __toModule(require("stripe"));
+var import_config = __toModule(require("../config"));
+var import_utils2 = __toModule(require("../utils"));
+var import_session = __toModule(require("../utils/session"));
+const eventCategory = "users";
+const apiVersion = "2020-03-02";
+var UserAccess;
+(function(UserAccess2) {
+  UserAccess2[UserAccess2["DEACTIVATED"] = 0] = "DEACTIVATED";
+  UserAccess2[UserAccess2["ACTIVE"] = 1] = "ACTIVE";
+  UserAccess2[UserAccess2["PREMIUM"] = 2] = "PREMIUM";
+  UserAccess2[UserAccess2["CONTENT_ADMIN"] = 3] = "CONTENT_ADMIN";
+  UserAccess2[UserAccess2["ADMIN"] = 4] = "ADMIN";
+})(UserAccess || (UserAccess = {}));
+const createToken = (userId, username, userAccess, expires = 15) => {
+  const now = import_luxon.DateTime.local();
+  const sessionExpires = now.plus({ minutes: expires });
+  const iat = Math.floor(now.toSeconds());
+  const exp = Math.floor(sessionExpires.toSeconds());
+  const token = (0, import_session.setSession)({
+    exp,
+    iat,
+    username,
+    userAccess,
+    userId
+  });
+  return {
+    expires: sessionExpires.toMillis(),
+    issued: now.toMillis(),
+    token
+  };
+};
+const getUserOptional = (fields = []) => fields.reduce((selects, field) => {
+  if (field.includes("Count")) {
+    return (0, import_utils2.selectReactionCountByType)("users", "u", field, selects);
+  }
+  return selects;
+}, { objects: [], queries: [] });
+const parseUserOptions = (options = {}) => {
+  const {
+    from = 0,
+    to = 30
+  } = options;
+  return __spreadProps(__spreadValues({}, options), {
+    limit: (0, import_utils2.getLimit)(from, to)
+  });
+};
+const addUser = async (context, args) => {
+  const action = "addUser";
+  const { database } = context;
+  const { user } = args;
+  const { email, password, phone, username } = user;
+  const salt = (0, import_utils.createHash)(`${username}${password}`, null);
+  const encryptedPassword = (0, import_utils.createPassword)(password, salt);
+  const formatUsername = (0, import_utils.parseUsername)(username);
+  const formatEmail = (0, import_utils.parseEmail)(email);
+  const formatPhone = (0, import_utils.parsePhone)(phone);
+  if ((0, import_isEmpty.default)(formatUsername) || (0, import_isEmpty.default)(password) || !(0, import_isEmpty.default)(formatPhone) && !(0, import_isEmpty.default)(formatEmail)) {
+    return (0, import_utils2.logException)({
+      action,
+      args: { username },
+      category: eventCategory,
+      value: import_utils2.ErrorTypes.INVALID_ARGUMENTS
+    }, context);
+  }
+  const filters = [`u.username == "${formatUsername}"`];
+  if (!(0, import_isEmpty.default)(formatEmail)) {
+    filters.push(`u.email == "${formatEmail}"`);
+  }
+  if (!(0, import_isEmpty.default)(formatPhone)) {
+    filters.push(`u.phone == ${formatPhone}`);
+  }
+  const checkQuery = `FOR u IN users
+    FILTER ${filters.join(" || ")}
+    RETURN u`;
+  const existingUsers = await database.query(checkQuery).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    args: { username },
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => null));
+  if (existingUsers.length) {
+    return (0, import_utils2.logException)({
+      action,
+      args: { username },
+      category: eventCategory,
+      value: import_utils2.ErrorTypes.EXISTING_USERNAME
+    }, context);
+  }
+  const verifiedEmailCode = Math.floor(1e5 + Math.random() * 9e5);
+  const verifiedPhoneCode = Math.floor(1e5 + Math.random() * 9e5);
+  const insert = {
+    _key: (0, import_utils.createHash)(username, null),
+    added: Date.now(),
+    email: formatEmail,
+    modified: Date.now(),
+    password: encryptedPassword,
+    phone: formatPhone,
+    salt,
+    username: formatUsername,
+    userAccess: 1,
+    verifiedEmail: false,
+    verifiedEmailCode,
+    verifiedPhone: false,
+    verifiedPhoneCode
+  };
+  const insertQuery = import_arangojs.aql`INSERT ${insert} IN users RETURN NEW`;
+  return await database.query(insertQuery).then((cursor) => cursor.next() || {}).catch((error) => (0, import_utils2.logError)({
+    action,
+    args: { username },
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => null));
+};
+const updateUser = async (context, user) => {
+  const action = "updateUser";
+  const { database } = context;
+  const _a = user, { _key, _id, id, tags = [], userId } = _a, updated = __objRest(_a, ["_key", "_id", "id", "tags", "userId"]);
+  let userDocId;
+  if (_id || id) {
+    userDocId = _id || id;
+  } else if (_key || userId) {
+    userDocId = `users/${_key || userId}`;
+  }
+  const userQuery = import_arangojs.aql`LET u = DOCUMENT(${userDocId})
+    UPDATE u WITH ${updated} IN users
+    RETURN NEW`;
+  const updatedUser = await database.query(userQuery).then((cursor) => cursor.next()).catch((error) => {
+    console.log(error);
+    throw error;
+  });
+  const tagCollection = database.collection("isTagged");
+  await Promise.all(tags.map(({ id: tagDocId, name }) => {
+    const edge = {
+      _from: tagDocId,
+      _key: (0, import_utils.createHash)(`isTagged-${tagDocId}-${userDocId}`),
+      _to: userDocId,
+      added: Date.now(),
+      name
+    };
+    const tagQuery = import_arangojs.aql`FOR it IN isTagged
+      FILTER it._from == ${tagDocId} && it._to == ${userDocId} && it.name == ${name}
+      LIMIT 1
+      RETURN it`;
+    return database.query(tagQuery).then((cursor) => cursor.next()).then((tagEdge) => {
+      if (!!tagEdge) {
+        return tagEdge;
+      }
+      return tagCollection.save(edge, { returnNew: true }).then(() => edge);
+    }).catch((error) => (0, import_utils2.logError)({
+      action,
+      category: eventCategory,
+      label: "db_error"
+    }, error, context).then(() => null));
+  }));
+  return updatedUser;
+};
+const confirmCode = async (context, args) => {
+  const action = "confirmEmail";
+  const { database, session: { userId: sessionId } } = context;
+  const { code, type } = args;
+  const userDocId = `users/${sessionId}`;
+  const aqlQuery = import_arangojs.aql`LET u = DOCUMENT(${userDocId}) RETURN u`;
+  try {
+    return database.query(aqlQuery).then((cursor) => cursor.next() || {}).then(({ verifiedEmailCode, verifiedPhoneCode }) => {
+      switch (type) {
+        case "email":
+          return code === verifiedEmailCode;
+        case "phone":
+          return code === verifiedPhoneCode;
+        default:
+          return false;
+      }
+    }).catch((error) => (0, import_utils2.logError)({
+      action,
+      args: { code, type, userId: sessionId },
+      category: eventCategory,
+      label: import_utils2.ErrorTypes.DATABASE_ERROR
+    }, error, context));
+  } catch (error) {
+    return false;
+  }
+};
+const deleteUser = (context, args) => {
+  const action = "deleteUser";
+  const { database, session: { userId: sessionId, userAccess: sessionAccess } } = context;
+  const { userId } = args;
+  const isAdmin = sessionAccess > 2;
+  if (!isAdmin && sessionId !== userId) {
+    (0, import_utils2.logException)({
+      action,
+      args,
+      category: eventCategory,
+      label: "unauthorized",
+      value: "invalid_session"
+    }, context);
+    return null;
+  }
+  const aqlQuery = import_arangojs.aql`FOR u IN users
+    FILTER u._key == ${userId}
+    LIMIT 1
+    REMOVE u IN users
+    RETURN OLD`;
+  const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+  return database.query(aqlQuery).then((cursor) => cursor.next()).then((user = {}) => stripeClient.customers.del(user.stripeCustomerId).then(() => stripeClient.accounts.del(user.stripeAccountId)).then(() => user)).catch((error) => {
+    throw error;
+  });
+};
+const deactivateUser = (context, userId) => {
+  const action = "delete";
+  const { database, session: { userId: sessionId, userAccess: sessionAccess } } = context;
+  const isAdmin = sessionAccess > 2;
+  if (!isAdmin && sessionId !== userId) {
+    (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "unauthorized",
+      value: "invalid_session"
+    }, context);
+    return null;
+  }
+  const updated = {
+    userAccess: 0
+  };
+  const aqlQuery = import_arangojs.aql`UPDATE ${userId} WITH ${updated} IN users LIMIT 1 RETURN NEW`;
+  return database.query(aqlQuery).then((cursor) => cursor.next()).catch((error) => {
+    throw error;
+  });
+};
+const getDisplayName = (user = {}) => {
+  const { first, last, name = "", username = "" } = user;
+  const fullname = [first, last].join(" ").trim();
+  if (!(0, import_isEmpty.default)(name)) {
+    return name;
+  } else if (fullname !== "") {
+    return fullname;
+  } else if (!(0, import_isEmpty.default)(username)) {
+    return username;
+  }
+  return "Unknown";
+};
+const getSessionUser = (context) => {
+  const action = "getSessionUser";
+  const { database, fields, session: { userId: sessionId, username } } = context;
+  const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+  const aqlQuery = `LET u = DOCUMENT("users/${sessionId}")
+  ${selectQueries.join("\n")}
+  RETURN MERGE(u, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQuery).then((cursor) => cursor.next()).then((user = {}) => user).catch((error) => (0, import_utils2.logError)({
+    action,
+    args: { username, userId: sessionId },
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context));
+};
+const getUser = (context, args) => {
+  const action = "getUser";
+  const { userId } = args;
+  const { database, fields } = context;
+  const formatUserId = (0, import_utils.parseId)(userId);
+  const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+  const aqlQuery = `LET u = DOCUMENT("users/${formatUserId}")
+    ${selectQueries.join("\n")}
+    FILTER u.userAccess > 0
+    RETURN MERGE(u, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQuery).then((cursor) => cursor.next()).then((user = {}) => user).catch((error) => (0, import_utils2.logError)({
+    action,
+    args,
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => {
+  }));
+};
+const getUsers = (context, options) => {
+  const action = "getUserList";
+  const { database, fields } = context;
+  const { limit, username } = parseUserOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+  const filterBy = ["u.userAccess > 0"];
+  if (!(0, import_isEmpty.default)(username)) {
+    filterBy.push(`CONTAINS(u.username, "${(0, import_utils.parseUsername)(username)}")`);
+  }
+  const aqlQuery = `FOR u IN users
+    FILTER ${filterBy.join(" && ")}
+    ${selectQueries.join("\n")}
+    ${limit.aql}
+    SORT u.username
+    RETURN MERGE(u, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => []));
+};
+const getUsersByReactions = (context, { reactions = [], username }, options) => {
+  const action = "getUsersByReactions";
+  const { database, fields, session: { userId: sessionId } } = context;
+  const formatReactions = reactions.map((reactionName) => (0, import_utils.parseChar)(reactionName, 32).toLowerCase());
+  const { limit } = parseUserOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+  const formatSessionId = `users/${sessionId}`;
+  const formatUsername = (0, import_utils.parseUsername)(username);
+  const filterBy = [`POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`];
+  if (!(0, import_isEmpty.default)(username)) {
+    filterBy.push(`CONTAINS(u.username, "${formatUsername}")`);
+  }
+  const aqlQuery = `FOR u, r IN OUTBOUND "${formatSessionId}" hasReactions
+    OPTIONS {vertexCollections: "users"}
+    ${selectQueries.join("\n")}
+    ${filterBy.length ? `FILTER ${filterBy.join(" && ")}` : ""}
+    ${limit.aql}
+    RETURN MERGE(u, {${selectObjects.join(", ")}})`;
+  console.log({ aqlQuery });
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => []));
+};
+const getUsersByTags = (context, { tags, username }, options) => {
+  const action = "getUsersByTags";
+  const { database, fields, session: { userId: sessionId } } = context;
+  const formatTags = tags.reduce((list, tagName) => {
+    if (!(0, import_isEmpty.default)(tagName)) {
+      list.push((0, import_utils.parseChar)(tagName, 32).toLowerCase());
+    }
+    return list;
+  }, []);
+  const { limit } = parseUserOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+  const formatUsername = (0, import_utils.parseUsername)(username);
+  const filterBy = [`u._key != "${sessionId}"`];
+  if (!(0, import_isEmpty.default)(username)) {
+    filterBy.push(`CONTAINS(u.username, "${formatUsername}")`);
+  }
+  const aqlQuery = `FOR t IN tags
+    FILTER POSITION(${JSON.stringify(formatTags)}, LOWER(t.name))
+    FOR u, it IN OUTBOUND t isTagged
+    OPTIONS {bfs: true, uniqueVertices: "global", vertexCollections: "users"}
+    ${selectQueries.join("\n")}
+    ${filterBy.length ? `FILTER ${filterBy.join(" && ")}` : ""}
+    ${limit.aql}
+    RETURN DISTINCT MERGE(u, {${selectObjects.join(", ")}})`;
+  console.log("getUsersByTags", aqlQuery);
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => []));
+};
+const getUsersByLatest = (context, { username }, options) => {
+  const action = "getUsersByLatest";
+  const { database, fields, session: { userId } } = context;
+  const { limit } = parseUserOptions(options);
+  const filter = ["u._id != session._id"];
+  const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+  if (!(0, import_isEmpty.default)(username)) {
+    filter.push(`CONTAINS(u.username, "${(0, import_utils.parseUsername)(username)}")`);
+  }
+  const aqlQuery = `FOR u IN users
+    LET session = DOCUMENT("users/${userId}")
+    FILTER ${filter.join(" && ")}
+    ${selectQueries.join("\n")}
+    LET distance = DISTANCE(u.latitude || 0, u.longitude || 0, session.latitude || 0, session.longitude || 0)
+    ${limit.aql}
+    SORT distance ASC, u.added DESC
+    RETURN MERGE(u, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => []));
+};
+const refreshSession = async (context, { expires, token }) => {
+  const { error } = (0, import_session.getSession)(token);
+  if (error) {
+    return { errors: [error] };
+  }
+  const { exp, userId, username, userAccess } = (0, import_session.getSession)(token);
+  const now = Math.ceil(import_luxon.DateTime.local().toSeconds());
+  if (exp > now) {
+    return createToken(userId, username, userAccess, expires);
+  }
+  return { errors: ["session_expired"] };
+};
+const signIn = async (context, args) => {
+  const action = "signIn";
+  const { expires, password, username } = args;
+  const formatUsername = (0, import_utils.parseUsername)(username);
+  const formatPassword = (0, import_utils.parsePassword)(password);
+  const formatExpires = (0, import_utils.parseNum)(expires) || 15;
+  const { database } = context;
+  if ((0, import_isEmpty.default)(formatUsername) || (0, import_isEmpty.default)(formatPassword)) {
+    return (0, import_utils2.logException)({
+      action,
+      args: { username },
+      category: eventCategory,
+      value: import_utils2.ErrorTypes.INVALID_ARGUMENTS
+    }, context);
+  }
+  const checkQuery = import_arangojs.aql`FOR u IN users
+    FILTER u.username == ${formatUsername}
+    LIMIT 1
+    RETURN u`;
+  const checkUser = await database.query(checkQuery).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    args: { username: formatUsername },
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => null));
+  if (!checkUser) {
+    return (0, import_utils2.logException)({
+      action,
+      args: { username },
+      category: eventCategory,
+      value: import_utils2.ErrorTypes.INVALID_AUTHENTICATION
+    }, context);
+  }
+  const { _key: userId, salt, userAccess } = checkUser;
+  const authPassword = (0, import_utils.createPassword)(formatPassword, salt);
+  if (checkUser.password !== authPassword) {
+    return (0, import_utils2.logException)({
+      action,
+      args: { username },
+      category: eventCategory,
+      value: import_utils2.ErrorTypes.INVALID_AUTHENTICATION
+    }, context);
+  }
+  return createToken(userId, username, userAccess, formatExpires);
+};
+const signOut = async (context, args) => {
+  const action = "signOut";
+  const { database, session: { userId: sessionId, username } } = context;
+  const userDocId = `users/${sessionId}`;
+  const update = {
+    lastOnline: Date.now(),
+    sessionId: null
+  };
+  const sessionQuery = import_arangojs.aql`LET u = DOCUMENT(${userDocId})
+    UPDATE u WITH ${update} IN users
+    LIMIT 1
+    RETURN NEW`;
+  try {
+    await database.query(sessionQuery).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+      action,
+      args: { username, userId: sessionId },
+      category: eventCategory,
+      label: import_utils2.ErrorTypes.DATABASE_ERROR
+    }, error, context));
+  } catch (error) {
+    return false;
+  }
+  return true;
+};
+const getActiveUserCount = (context) => {
+  const action = "getActiveUserCount";
+  const { database } = context;
+  const countQuery = import_arangojs.aql`LET docs = (
+    FOR u IN users
+    FILTER u.active == true
+    RETURN u
+  )
+  RETURN LENGTH(docs)`;
+  return database.query(countQuery).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: import_utils2.ErrorTypes.DATABASE_ERROR
+  }, error, context).then(() => 0));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UserAccess,
+  addUser,
+  confirmCode,
+  createToken,
+  deactivateUser,
+  deleteUser,
+  getActiveUserCount,
+  getDisplayName,
+  getSessionUser,
+  getUser,
+  getUserOptional,
+  getUsers,
+  getUsersByLatest,
+  getUsersByReactions,
+  getUsersByTags,
+  parseUserOptions,
+  refreshSession,
+  signIn,
+  signOut,
+  updateUser
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/users.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {\n  createHash,\n  createPassword,\n  parseChar,\n  parseEmail,\n  parseId,\n  parseNum,\n  parsePassword,\n  parsePhone,\n  parseUsername\n} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport isEmpty from 'lodash/isEmpty';\nimport {DateTime} from 'luxon';\nimport Stripe from 'stripe';\n\nimport {Config} from '../config';\nimport {ApiContext} from '../types/auth';\nimport {User} from '../types/users';\nimport {ErrorTypes, getLimit, logError, logException, selectReactionCountByType} from '../utils';\nimport {getSession, SessionError, SessionToken, setSession} from '../utils/session';\n\nconst eventCategory: string = 'users';\nconst apiVersion: any = '2020-03-02';\n\nexport interface UserOptions {\n  readonly from?: number;\n  readonly to?: number;\n  readonly username?: string;\n}\n\nexport enum UserAccess {\n  DEACTIVATED = 0,\n  ACTIVE = 1,\n  PREMIUM = 2,\n  CONTENT_ADMIN = 3,\n  ADMIN = 4\n}\n\nexport const createToken = (\n  userId: string,\n  username: string,\n  userAccess: number,\n  expires: number = 15\n): SessionToken => {\n  const now: DateTime = DateTime.local();\n  const sessionExpires: DateTime = now.plus({minutes: expires});\n  const iat: number = Math.floor(now.toSeconds());\n  const exp: number = Math.floor(sessionExpires.toSeconds());\n\n  const token = setSession({\n    exp,\n    iat,\n    username,\n    userAccess,\n    userId\n  });\n\n  return {\n    expires: sessionExpires.toMillis(),\n    issued: now.toMillis(),\n    token\n  };\n};\n\nexport const getUserOptional = (fields: string[] = []) =>\n  fields.reduce((selects: any, field: string) => {\n    if(field.includes('Count')) {\n      return selectReactionCountByType('users', 'u', field, selects);\n    }\n\n    return selects;\n  }, {objects: [], queries: []});\n\nexport const parseUserOptions = (options: UserOptions = {}) => {\n  const {\n    from = 0,\n    to = 30\n  } = options;\n\n  return {\n    ...options,\n    limit: getLimit(from, to)\n  };\n};\n\nexport const addUser = async (context: ApiContext, args: any): Promise<User> => {\n  const action: string = 'addUser';\n  const {database} = context;\n  const {user} = args;\n  const {email, password, phone, username} = user;\n  const salt: string = createHash(`${username}${password}`, null);\n  const encryptedPassword = createPassword(password, salt);\n  const formatUsername: string = parseUsername(username);\n  const formatEmail: string = parseEmail(email);\n  const formatPhone: string = parsePhone(phone);\n\n  if(isEmpty(formatUsername) || isEmpty(password) || (!isEmpty(formatPhone) && !isEmpty(formatEmail))) {\n    return logException({\n      action,\n      args: {username},\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ARGUMENTS\n    }, context);\n  }\n\n  const filters: string[] = [`u.username == \"${formatUsername}\"`];\n\n  if(!isEmpty(formatEmail)) {\n    filters.push(`u.email == \"${formatEmail}\"`);\n  }\n\n  if(!isEmpty(formatPhone)) {\n    filters.push(`u.phone == ${formatPhone}`);\n  }\n\n  const checkQuery: string = `FOR u IN users\n    FILTER ${filters.join(' || ')}\n    RETURN u`;\n  const existingUsers = await database.query(checkQuery)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error) => logError({\n      action,\n      args: {username},\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context)\n      .then(() => null)\n    );\n\n  if(existingUsers.length) {\n    return logException({\n      action,\n      args: {username},\n      category: eventCategory,\n      value: ErrorTypes.EXISTING_USERNAME\n    }, context);\n  }\n\n  const verifiedEmailCode: number = Math.floor(100000 + (Math.random() * 900000));\n  const verifiedPhoneCode: number = Math.floor(100000 + (Math.random() * 900000));\n\n  // Add new user properties\n  const insert: User = {\n    _key: createHash(username, null),\n    added: Date.now(),\n    email: formatEmail,\n    modified: Date.now(),\n    password: encryptedPassword,\n    phone: formatPhone,\n    salt,\n    username: formatUsername,\n    userAccess: 1,\n    verifiedEmail: false,\n    verifiedEmailCode,\n    verifiedPhone: false,\n    verifiedPhoneCode\n  };\n\n  // Add new user in ArangoDB\n  const insertQuery: AqlQuery = aql`INSERT ${insert} IN users RETURN NEW`;\n  return await database.query(insertQuery)\n    .then((cursor: ArrayCursor) => cursor.next() || {})\n    .catch((error) => logError({\n      action,\n      args: {username},\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context)\n      .then(() => null)\n    );\n};\n\nexport const updateUser = async (context: ApiContext, user: User): Promise<any> => {\n  const action: string = 'updateUser';\n  const {database} = context;\n  const {_key, _id, id, tags = [], userId, ...updated} = user;\n  let userDocId: string;\n\n  if(_id || id) {\n    userDocId = _id || id;\n  } else if(_key || userId) {\n    userDocId = `users/${_key || userId}`;\n  }\n\n  const userQuery: AqlQuery = aql`LET u = DOCUMENT(${userDocId})\n    UPDATE u WITH ${updated} IN users\n    RETURN NEW`;\n\n  const updatedUser = await database.query(userQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      console.log(error);\n      throw error;\n    });\n\n  const tagCollection: EdgeCollection = database.collection('isTagged');\n  await Promise.all(tags.map(({id: tagDocId, name}) => {\n    const edge = {\n      _from: tagDocId,\n      _key: createHash(`isTagged-${tagDocId}-${userDocId}`),\n      _to: userDocId,\n      added: Date.now(),\n      name\n    };\n    const tagQuery: AqlQuery = aql`FOR it IN isTagged\n      FILTER it._from == ${tagDocId} && it._to == ${userDocId} && it.name == ${name}\n      LIMIT 1\n      RETURN it`;\n\n    return database.query(tagQuery)\n      .then((cursor: ArrayCursor) => cursor.next())\n      .then((tagEdge) => {\n        if(!!tagEdge) {\n          return tagEdge;\n        }\n\n        return tagCollection.save(edge, {returnNew: true}).then(() => edge);\n      })\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: 'db_error'\n      }, error, context).then(() => null));\n  }));\n\n  return updatedUser;\n};\n\nexport const confirmCode = async (context: ApiContext, args): Promise<boolean> => {\n  const action: string = 'confirmEmail';\n  const {database, session: {userId: sessionId}} = context;\n  const {code, type} = args;\n  const userDocId: string = `users/${sessionId}`;\n\n  const aqlQuery: AqlQuery = aql`LET u = DOCUMENT(${userDocId}) RETURN u`;\n\n  try {\n    return database.query(aqlQuery)\n      .then((cursor) => cursor.next() || {})\n      .then(({verifiedEmailCode, verifiedPhoneCode}: User) => {\n        switch(type) {\n          case 'email':\n            return code === verifiedEmailCode;\n          case 'phone':\n            return code === verifiedPhoneCode;\n          default:\n            return false;\n        }\n      })\n      .catch((error) => logError({\n        action,\n        args: {code, type, userId: sessionId},\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context)\n      );\n  } catch(error) {\n    return false;\n  }\n};\n\nexport const deleteUser = (context: ApiContext, args: any): Promise<any> => {\n  const action: string = 'deleteUser';\n  const {database, session: {userId: sessionId, userAccess: sessionAccess}} = context;\n  const {userId} = args;\n  const isAdmin: boolean = sessionAccess > 2;\n\n  if(!isAdmin && (sessionId !== userId)) {\n    logException({\n      action,\n      args,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context);\n    return null;\n  }\n\n  const aqlQuery: AqlQuery = aql`FOR u IN users\n    FILTER u._key == ${userId}\n    LIMIT 1\n    REMOVE u IN users\n    RETURN OLD`;\n\n  // Stripe\n  const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((user: User = {}) => stripeClient.customers.del(user.stripeCustomerId)\n      .then(() => stripeClient.accounts.del(user.stripeAccountId))\n      .then(() => user))\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const deactivateUser = (context: ApiContext, userId: string): Promise<User> => {\n  const action: string = 'delete';\n  const {database, session: {userId: sessionId, userAccess: sessionAccess}} = context;\n  const isAdmin: boolean = sessionAccess > 2;\n\n  if(!isAdmin && (sessionId !== userId)) {\n    logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context);\n    return null;\n  }\n\n  const updated: User = {\n    userAccess: 0\n  };\n  const aqlQuery: AqlQuery = aql`UPDATE ${userId} WITH ${updated} IN users LIMIT 1 RETURN NEW`;\n\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getDisplayName = (user: User = {}): string => {\n  const {first, last, name = '', username = ''} = user;\n  const fullname: string = ([first, last]).join(' ').trim();\n\n  if(!isEmpty(name)) {\n    return name;\n  } else if(fullname !== '') {\n    return fullname;\n  } else if(!isEmpty(username)) {\n    return username;\n  }\n\n  return 'Unknown';\n};\n\nexport const getSessionUser = (context: ApiContext): Promise<User> => {\n  const action: string = 'getSessionUser';\n  const {database, fields, session: {userId: sessionId, username}} = context;\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n\n  const aqlQuery: string = `LET u = DOCUMENT(\"users/${sessionId}\")\n  ${selectQueries.join('\\n')}\n  RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((user = {}) => user)\n    .catch((error: Error) => logError({\n      action,\n      args: {username, userId: sessionId},\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getUser = (context: ApiContext, args: any): Promise<User> => {\n  const action: string = 'getUser';\n  const {userId} = args;\n  const {database, fields} = context;\n  const formatUserId: string = parseId(userId);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n\n  // Get data from database\n  const aqlQuery: string = `LET u = DOCUMENT(\"users/${formatUserId}\")\n    ${selectQueries.join('\\n')}\n    FILTER u.userAccess > 0\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((user = {}) => user)\n    .catch((error: Error) => logError({\n      action,\n      args,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context)\n      .then(() => { }));\n};\n\nexport const getUsers = (context: ApiContext, options?: UserOptions): Promise<User[]> => {\n  const action: string = 'getUserList';\n  const {database, fields} = context;\n  const {limit, username} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const filterBy: string[] = ['u.userAccess > 0'];\n\n  if(!isEmpty(username)) {\n    filterBy.push(`CONTAINS(u.username, \"${parseUsername(username)}\")`);\n  }\n\n  // Get data from database\n  const aqlQuery: string = `FOR u IN users\n    FILTER ${filterBy.join(' && ')}\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT u.username\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => []));\n};\n\nexport const getUsersByReactions = (\n  context: ApiContext,\n  {reactions = [], username}: any,\n  options?: UserOptions\n): Promise<User[]> => {\n  const action: string = 'getUsersByReactions';\n  const {database, fields, session: {userId: sessionId}} = context;\n  const formatReactions: string[] =  reactions.map((reactionName: string) => parseChar(reactionName, 32).toLowerCase());\n  const {limit} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatUsername: string = parseUsername(username);\n  const filterBy: string[] = [`POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`];\n\n  if(!isEmpty(username)) {\n    filterBy.push(`CONTAINS(u.username, \"${formatUsername}\")`);\n  }\n\n  // Get data from database\n  const aqlQuery: string = `FOR u, r IN OUTBOUND \"${formatSessionId}\" hasReactions\n    OPTIONS {vertexCollections: \"users\"}\n    ${selectQueries.join('\\n')}\n    ${filterBy.length ? `FILTER ${filterBy.join(' && ')}` : ''}\n    ${limit.aql}\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  console.log({aqlQuery});\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => []));\n};\n\nexport const getUsersByTags = (\n  context: ApiContext,\n  {tags, username}: any,\n  options?: UserOptions\n): Promise<User[]> => {\n  const action: string = 'getUsersByTags';\n  const {database, fields, session: {userId: sessionId}} = context;\n  const formatTags: string[] =  tags.reduce((list: string[], tagName: string) => {\n    if(!isEmpty(tagName)) {\n      list.push(parseChar(tagName, 32).toLowerCase());\n    }\n\n    return list;\n  }, []);\n  const {limit} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n\n  const formatUsername: string = parseUsername(username);\n  const filterBy: string[] = [`u._key != \"${sessionId}\"`];\n\n  if(!isEmpty(username)) {\n    filterBy.push(`CONTAINS(u.username, \"${formatUsername}\")`);\n  }\n\n  // Get data from database\n  const aqlQuery: string = `FOR t IN tags\n    FILTER POSITION(${JSON.stringify(formatTags)}, LOWER(t.name))\n    FOR u, it IN OUTBOUND t isTagged\n    OPTIONS {bfs: true, uniqueVertices: \"global\", vertexCollections: \"users\"}\n    ${selectQueries.join('\\n')}\n    ${filterBy.length ? `FILTER ${filterBy.join(' && ')}` : ''}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(u, {${selectObjects.join(', ')}})`;\n\n  console.log('getUsersByTags', aqlQuery);\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => []));\n};\n\nexport const getUsersByLatest = (context: ApiContext, {username}, options?: UserOptions): Promise<User[]> => {\n  const action: string = 'getUsersByLatest';\n  const {database, fields, session: {userId}} = context;\n  const {limit} = parseUserOptions(options);\n  const filter = ['u._id != session._id'];\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n\n  if(!isEmpty(username)) {\n    filter.push(`CONTAINS(u.username, \"${parseUsername(username)}\")`);\n  }\n\n  // Get data from database\n  const aqlQuery: string = `FOR u IN users\n    LET session = DOCUMENT(\"users/${userId}\")\n    FILTER ${filter.join(' && ')}\n    ${selectQueries.join('\\n')}\n    LET distance = DISTANCE(u.latitude || 0, u.longitude || 0, session.latitude || 0, session.longitude || 0)\n    ${limit.aql}\n    SORT distance ASC, u.added DESC\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => []));\n};\n\nexport const refreshSession = async (context: ApiContext, {expires, token}): Promise<SessionToken | SessionError> => {\n  const {error} = getSession(token);\n\n  if(error) {\n    return {errors: [error]};\n  }\n\n  const {exp, userId, username, userAccess} = getSession(token);\n  const now: number = Math.ceil(DateTime.local().toSeconds());\n\n  if(exp > now) {\n    return createToken(userId, username, userAccess, expires);\n  }\n\n  return {errors: ['session_expired']};\n};\n\nexport const signIn = async (context: ApiContext, args): Promise<SessionToken> => {\n  const action: string = 'signIn';\n  const {expires, password, username} = args;\n  const formatUsername: string = parseUsername(username);\n  const formatPassword: string = parsePassword(password);\n  const formatExpires: number = parseNum(expires) || 15;\n  const {database} = context;\n\n  if(isEmpty(formatUsername) || isEmpty(formatPassword)) {\n    return logException({\n      action,\n      args: {username},\n      category: eventCategory,\n      value: ErrorTypes.INVALID_ARGUMENTS\n    }, context);\n  }\n\n  const checkQuery: AqlQuery = aql`FOR u IN users\n    FILTER u.username == ${formatUsername}\n    LIMIT 1\n    RETURN u`;\n  const checkUser: User = await database.query(checkQuery)\n    .then((cursor) => cursor.next())\n    .catch((error) => logError({\n      action,\n      args: {username: formatUsername},\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context)\n      .then(() => null)\n    );\n\n  if(!checkUser) {\n    return logException({\n      action,\n      args: {username},\n      category: eventCategory,\n      value: ErrorTypes.INVALID_AUTHENTICATION\n    }, context);\n  }\n\n  const {_key: userId, salt, userAccess} = checkUser;\n  const authPassword: string = createPassword(formatPassword, salt);\n\n  if(checkUser.password !== authPassword) {\n    return logException({\n      action,\n      args: {username},\n      category: eventCategory,\n      value: ErrorTypes.INVALID_AUTHENTICATION\n    }, context);\n  }\n\n  return createToken(userId, username, userAccess, formatExpires);\n};\n\nexport const signOut = async (context: ApiContext, args): Promise<boolean> => {\n  const action: string = 'signOut';\n  const {database, session: {userId: sessionId, username}} = context;\n  const userDocId: string = `users/${sessionId}`;\n\n  const update = {\n    lastOnline: Date.now(),\n    sessionId: null\n  };\n  const sessionQuery: AqlQuery = aql`LET u = DOCUMENT(${userDocId})\n    UPDATE u WITH ${update} IN users\n    LIMIT 1\n    RETURN NEW`;\n\n  try {\n    await database.query(sessionQuery)\n      .then((cursor) => cursor.next())\n      .catch((error) => logError({\n        action,\n        args: {username, userId: sessionId},\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context)\n      );\n  } catch(error) {\n    return false;\n  }\n\n  return true;\n};\n\nexport const getActiveUserCount = (context: ApiContext) => {\n  const action: string = 'getActiveUserCount';\n  const {database} = context;\n  const countQuery: AqlQuery = aql`LET docs = (\n    FOR u IN users\n    FILTER u.active == true\n    RETURN u\n  )\n  RETURN LENGTH(docs)`;\n\n  return database.query(countQuery)\n    .then((cursor) => cursor.next())\n    .catch((error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context)\n      .then(() => 0)\n    );\n};\n"],
  "mappings": "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",
  "names": []
}


package/lib/{data → actions}/websockets.d.ts

@@ -1,6 +1,6 @@
 import { ApiContext } from '../types/auth';
 export declare const addConnection: (connectionId: string, token: string) => Promise<any>;
-export declare const getConnectionBySub: (sub: string) => Promise<any>;
+export declare const getConnectionByUser: (userId: string) => Promise<any>;
 export declare const getConnectionById: (connectionId: string) => Promise<any>;
 export declare const getConnectionByConvo: (context: ApiContext, convoId: string) => Promise<any>;
 export declare const removeConnection: (connectionId: string) => Promise<any>;